import collections
from db_base import db_base_Exception
+import nfvo_db
+from threading import Lock
+from time import time
+import openvim.ovim as Ovim
+
global global_config
global vimconn_imported
global logger
global default_volume_size
default_volume_size = '5' #size in GB
-
+global ovim
+ovim = None
+global_config = None
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()
+global_instance_tasks = {}
+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, depends=None):
+ task_id = get_task_id()
+ task = {"status": "enqueued", "id": task_id, "name": name, "params": params}
+ if depends:
+ task["depends"] = depends
+ 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 = datatacenter_name[:16] + "." + tenant_name[:16]
+ name = datacenter_name[:16] + "." + tenant_name[:16]
if name not in vim_threads["names"]:
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'])
+ global ovim
+
+ # Initialize openvim for SDN control
+ # TODO: Avoid static configuration by adding new parameters to openmanod.cfg
+ # TODO: review ovim.py to delete not needed configuration
+ ovim_configuration = {
+ 'logger_name': 'openvim',
+ 'network_vlan_range_start': 1000,
+ 'network_vlan_range_end': 4096,
+ 'log_level_db': 'DEBUG',
+ 'db_name': 'mano_vim_db',
+ 'db_host': 'localhost',
+ 'db_user': 'vim',
+ 'db_passwd': 'vimpw',
+ 'database_version': '0.15',
+ 'bridge_ifaces': {},
+ 'mode': 'normal',
+ 'of_controller_nets_with_same_vlan': True,
+ 'network_type': 'bridge',
+ #TODO: log_level_of should not be needed. To be modified in ovim
+ 'log_level_of': 'DEBUG'
+ }
+ ovim = Ovim.ovim(ovim_configuration)
+ ovim.start_service()
+
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',
try:
vims = mydb.get_rows(FROM=from_, SELECT=select_)
for vim in vims:
- extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id')}
+ extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id'),
+ 'datacenter_id': vim.get('datacenter_id')}
if vim["config"]:
extra.update(yaml.load(vim["config"]))
if vim.get('dt_config'):
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)
+ vim["type"], module, type(e).__name__, str(e)), HTTP_Bad_Request)
+ thread_id = vim['datacenter_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
- )
+ 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, thread_name)
+ new_thread = vim_thread.vim_thread(myvim, task_lock, thread_name, vim['datacenter_name'],
+ vim['datacenter_tenant_id'], db=db, db_lock=db_lock, ovim=ovim)
new_thread.start()
- thread_id = vim["datacenter_id"] + "-" + vim['nfvo_tenant_id']
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():
+ global ovim, global_config
+ if ovim:
+ ovim.stop_service()
for thread_id,thread in vim_threads["running"].items():
- thread.insert_task("exit")
+ thread.insert_task(new_task("exit", None))
vim_threads["deleting"][thread_id] = thread
- vim_threads["running"]={}
+ vim_threads["running"] = {}
+ if global_config and global_config.get("console_thread"):
+ for thread in global_config["console_thread"]:
+ thread.terminate = True
+
def get_flavorlist(mydb, vnf_id, nfvo_tenant=None):
'''Obtain flavorList
flavorList.append(flavor['flavor_id'])
return flavorList
+
def get_imagelist(mydb, vnf_id, nfvo_tenant=None):
'''Obtain imageList
return result, content:
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
vims = mydb.get_rows(FROM=from_, SELECT=select_, WHERE=WHERE_dict )
vim_dict={}
for vim in vims:
- extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id')}
+ extra={'datacenter_tenant_id': vim.get('datacenter_tenant_id'),
+ 'datacenter_id': vim.get('datacenter_id')}
if vim["config"]:
extra.update(yaml.load(vim["config"]))
if vim.get('dt_config'):
vim["type"], module, type(e).__name__, str(e)), HTTP_Bad_Request)
try:
+ if 'datacenter_tenant_id' in vim:
+ thread_id = vim["datacenter_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),
+ 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)
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
else:
return False," Rollback fails to delete: " + str(undeleted_items)
+
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
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'),
return flavor_vim_id if only_create_at_vim else flavor_mano_id
+
def new_vnf(mydb, tenant_id, vnf_descriptor):
global global_config
#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
#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)
#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:
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 c
+
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"]
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)
#logger.error("start_scenario %s", error_text)
raise NfvoException(error_text, e.http_code)
+
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
return new_cloud_config
+def get_vim_thread(mydb, tenant_id, datacenter_id_name=None, datacenter_tenant_id=None):
+ datacenter_id = None
+ datacenter_name = None
+ thread = None
+ try:
+ if datacenter_tenant_id:
+ thread_id = datacenter_tenant_id
+ thread = vim_threads["running"].get(datacenter_tenant_id)
+ else:
+ where_={"td.nfvo_tenant_id": tenant_id}
+ if datacenter_id_name:
+ if utils.check_valid_uuid(datacenter_id_name):
+ datacenter_id = datacenter_id_name
+ where_["dt.datacenter_id"] = datacenter_id
+ else:
+ datacenter_name = datacenter_id_name
+ where_["d.name"] = datacenter_name
+ if datacenter_tenant_id:
+ where_["dt.uuid"] = datacenter_tenant_id
+ datacenters = mydb.get_rows(
+ SELECT=("dt.uuid as datacenter_tenant_id",),
+ FROM="datacenter_tenants as dt join tenants_datacenters as td on dt.uuid=td.datacenter_tenant_id "
+ "join datacenters as d on d.uuid=dt.datacenter_id",
+ WHERE=where_)
+ if len(datacenters) > 1:
+ raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
+ elif datacenters:
+ thread_id = datacenters[0]["datacenter_tenant_id"]
+ thread = vim_threads["running"].get(thread_id)
+ if not thread:
+ raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), HTTP_Not_Found)
+ return thread_id, thread
+ except db_base_Exception as e:
+ raise NfvoException("{} {}".format(type(e).__name__ , str(e)), e.http_code)
def get_datacenter_by_name_uuid(mydb, tenant_id, datacenter_id_name=None, **extra_filter):
datacenter_id = None
raise NfvoException("More than one datacenters found, try to identify with uuid", HTTP_Conflict)
return vims.keys()[0], vims.values()[0]
+
def update(d, u):
'''Takes dict d and updates it with the values in dict u.'''
'''It merges all depth levels'''
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 = {}
- datacenter2tenant = {}
+ myvim_threads_id = {}
+ instance_tasks={}
+ tasks_to_launch={}
datacenter = instance_dict.get("datacenter")
default_datacenter_id, vim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
myvims[default_datacenter_id] = vim
- datacenter2tenant[default_datacenter_id] = vim['config']['datacenter_tenant_id']
+ myvim_threads_id[default_datacenter_id], _ = get_vim_thread(mydb, tenant_id, default_datacenter_id)
+ tasks_to_launch[myvim_threads_id[default_datacenter_id]] = []
#myvim_tenant = myvim['tenant_id']
# default_datacenter_name = vim['name']
rollbackList=[]
instance_name = instance_dict["name"]
instance_description = instance_dict.get("description")
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
- datacenter2tenant[d] = v['config']['datacenter_tenant_id']
- site["datacenter"] = d #change name to id
+ myvim_threads_id[d],_ = get_vim_thread(mydb, tenant_id, site["datacenter"])
+ tasks_to_launch[myvim_threads_id[d]] = []
+ 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
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
- datacenter2tenant[d] = v['config']['datacenter_tenant_id']
+ myvim_threads_id[d],_ = get_vim_thread(mydb, tenant_id, vnf_instance_desc["datacenter"])
+ tasks_to_launch[myvim_threads_id[d]] = []
scenario_vnf["datacenter"] = vnf_instance_desc["datacenter"]
#0.1 parse cloud-config parameters
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_id = myvim_threads_id[ site["datacenter"] ]
else:
vim = myvims[ default_datacenter_id ]
datacenter_id = default_datacenter_id
+ myvim_thread_id = myvim_threads_id[default_datacenter_id]
net_type = sce_net['type']
lookfor_filter = {'admin_state_up': True, 'status': 'ACTIVE'} #'shared': True
if sce_net["external"]:
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 = task["id"]
+ instance_tasks[task_id] = task
+ tasks_to_launch[myvim_thread_id].append(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_id = myvim_threads_id[ sce_vnf["datacenter"]]
else:
vim = myvims[ default_datacenter_id ]
datacenter_id = default_datacenter_id
+ myvim_thread_id = myvim_threads_id[default_datacenter_id]
descriptor_net = instance_dict.get("vnfs",{}).get(sce_vnf["name"],{})
net_name = descriptor_net.get("name")
if not net_name:
net_name = "%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 = task["id"]
+ instance_tasks[task_id] = task
+ tasks_to_launch[myvim_thread_id].append(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_id = myvim_threads_id[ sce_vnf["datacenter"] ]
datacenter_id = sce_vnf["datacenter"]
else:
vim = myvims[ default_datacenter_id ]
+ myvim_thread_id = myvim_threads_id[ default_datacenter_id ]
datacenter_id = default_datacenter_id
sce_vnf["datacenter_id"] = datacenter_id
i = 0
flavor_dict['extended']= yaml.load(flavor_dict['extended'])
flavor_id = create_or_use_flavor(mydb, {datacenter_id: vim}, flavor_dict, rollbackList, True)
-
-
-
#Obtain information for additional disks
extended_flavor_dict = mydb.get_rows(FROM='datacenters_flavors', SELECT=('extended',), WHERE={'vim_id': flavor_id})
if not extended_flavor_dict:
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 = {}
break
else:
netDict['net_id'] = auxNetDict[ sce_vnf['uuid'] ][ iface['net_id'] ]
+ if netDict.get('net_id') and 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
cloud_config_vm = unify_cloud_config(vm["boot_data"], cloud_config)
else:
cloud_config_vm = cloud_config
- vm_id = vim.new_vminstance(myVMDict['name'],myVMDict['description'],myVMDict.get('start', None),
- myVMDict['imageRef'],myVMDict['flavorRef'],myVMDict['networks'], cloud_config = cloud_config_vm,
- disk_list = myVMDict['disks'])
-
+ 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)
+ instance_tasks[task["id"]] = task
+ tasks_to_launch[myvim_thread_id].append(task)
+ vm_id = task["id"]
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]
if net["name"]==iface["internal_name"]:
iface["vim_id"]=net["vim_id"]
break
- scenarioDict["datacenter2tenant"] = datacenter2tenant
+ scenarioDict["datacenter2tenant"] = myvim_threads_id
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)
+ for myvim_thread_id,task_list in tasks_to_launch.items():
+ for task in task_list:
+ vim_threads["running"][myvim_thread_id].insert_task(task)
+
+ global_instance_tasks[instance_id] = instance_tasks
+ # Update database with those ended instance_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)
#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(mydb, tenant_id, sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
+ except NfvoException as e:
+ logger.error(str(e))
+ myvim_thread = None
+ myvim_threads[datacenter_key] = myvim_thread
vims = get_vim(mydb, tenant_id, datacenter_id=sce_vnf["datacenter_id"],
datacenter_tenant_id=sce_vnf["datacenter_tenant_id"])
if len(vims) == 0:
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 = global_instance_tasks[instance_id].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, vm["interfaces"]), depends={task_id: old_task})
+ else: #ok
+ task = new_task("del-vm", (old_task["result"], vm["interfaces"]))
+ else:
+ task = new_task("del-vm", (vm['vim_vm_id'], vm["interfaces"]) )
+ 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",
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(mydb, tenant_id, sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
+ except NfvoException as e:
+ logger.error(str(e))
+ myvim_thread = None
+ myvim_threads[datacenter_key] = myvim_thread
vims = get_vim(mydb, tenant_id, datacenter_id=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 = global_instance_tasks[instance_id].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'], net['sdn_net_id']))
+ 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:
- result: <0 if there is any unexpected error, n>=0 if no errors where n is the number of vms and nets that couldn't be updated in the database
- error_msg
'''
- # 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={}
-
- # 1. Getting VIM vm and net list
- vms_updated = [] #List of VM instance uuids in openmano that were updated
- vms_notupdated=[]
- vm_list = {}
- for sce_vnf in instanceDict['vnfs']:
- datacenter_key = (sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
- if datacenter_key not in vm_list:
- vm_list[datacenter_key] = []
- if datacenter_key not in myvims:
- vims = get_vim(mydb, nfvo_tenant, datacenter_id=sce_vnf["datacenter_id"],
- datacenter_tenant_id=sce_vnf["datacenter_tenant_id"])
- if len(vims) == 0:
- logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"]))
- myvims[datacenter_key] = None
- else:
- myvims[datacenter_key] = vims.values()[0]
- for vm in sce_vnf['vms']:
- vm_list[datacenter_key].append(vm['vim_vm_id'])
- vms_notupdated.append(vm["uuid"])
-
- nets_updated = [] #List of VM instance uuids in openmano that were updated
- nets_notupdated=[]
- net_list = {}
- for net in instanceDict['nets']:
- datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"])
- if datacenter_key not in net_list:
- net_list[datacenter_key] = []
- if datacenter_key not in myvims:
- vims = get_vim(mydb, nfvo_tenant, datacenter_id=net["datacenter_id"],
- datacenter_tenant_id=net["datacenter_tenant_id"])
- if len(vims) == 0:
- logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"]))
- myvims[datacenter_key] = None
- else:
- myvims[datacenter_key] = vims.values()[0]
-
- net_list[datacenter_key].append(net['vim_net_id'])
- nets_notupdated.append(net["uuid"])
-
- # 1. Getting the status of all VMs
- vm_dict={}
- for datacenter_key in myvims:
- if not vm_list.get(datacenter_key):
- continue
- failed = True
- failed_message=""
- if not myvims[datacenter_key]:
- failed_message = "datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"])
- else:
- try:
- vm_dict.update(myvims[datacenter_key].refresh_vms_status(vm_list[datacenter_key]) )
- failed = False
- except vimconn.vimconnException as e:
- logger.error("VIM exception %s %s", type(e).__name__, str(e))
- failed_message = str(e)
- if failed:
- for vm in vm_list[datacenter_key]:
- vm_dict[vm] = {'status': "VIM_ERROR", 'error_msg': failed_message}
-
- # 2. Update the status of VMs in the instanceDict, while collects the VMs whose status changed
- for sce_vnf in instanceDict['vnfs']:
- for vm in sce_vnf['vms']:
- vm_id = vm['vim_vm_id']
- interfaces = vm_dict[vm_id].pop('interfaces', [])
- #2.0 look if contain manamgement interface, and if not change status from ACTIVE:NoMgmtIP to ACTIVE
- has_mgmt_iface = False
- for iface in vm["interfaces"]:
- if iface["type"]=="mgmt":
- has_mgmt_iface = True
- if vm_dict[vm_id]['status'] == "ACTIVE:NoMgmtIP" and not has_mgmt_iface:
- vm_dict[vm_id]['status'] = "ACTIVE"
- if vm_dict[vm_id].get('error_msg') and len(vm_dict[vm_id]['error_msg']) >= 1024:
- vm_dict[vm_id]['error_msg'] = vm_dict[vm_id]['error_msg'][:516] + " ... " + vm_dict[vm_id]['error_msg'][-500:]
- if vm['status'] != vm_dict[vm_id]['status'] or vm.get('error_msg')!=vm_dict[vm_id].get('error_msg') or vm.get('vim_info')!=vm_dict[vm_id].get('vim_info'):
- vm['status'] = vm_dict[vm_id]['status']
- vm['error_msg'] = vm_dict[vm_id].get('error_msg')
- vm['vim_info'] = vm_dict[vm_id].get('vim_info')
- # 2.1. Update in openmano DB the VMs whose status changed
- try:
- updates = mydb.update_rows('instance_vms', UPDATE=vm_dict[vm_id], WHERE={'uuid':vm["uuid"]})
- vms_notupdated.remove(vm["uuid"])
- if updates>0:
- vms_updated.append(vm["uuid"])
- except db_base_Exception as e:
- logger.error("nfvo.refresh_instance error database update: %s", str(e))
- # 2.2. Update in openmano DB the interface VMs
- for interface in interfaces:
- #translate from vim_net_id to instance_net_id
- network_id_list=[]
- for net in instanceDict['nets']:
- if net["vim_net_id"] == interface["vim_net_id"]:
- network_id_list.append(net["uuid"])
- if not network_id_list:
- continue
- del interface["vim_net_id"]
- try:
- for network_id in network_id_list:
- mydb.update_rows('instance_interfaces', UPDATE=interface, WHERE={'instance_vm_id':vm["uuid"], "instance_net_id":network_id})
- except db_base_Exception as e:
- logger.error( "nfvo.refresh_instance error with vm=%s, interface_net_id=%s", vm["uuid"], network_id)
-
- # 3. Getting the status of all nets
- net_dict = {}
- for datacenter_key in myvims:
- if not net_list.get(datacenter_key):
- continue
- failed = True
- failed_message = ""
- if not myvims[datacenter_key]:
- failed_message = "datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"])
- else:
- try:
- net_dict.update(myvims[datacenter_key].refresh_nets_status(net_list[datacenter_key]) )
- failed = False
- except vimconn.vimconnException as e:
- logger.error("VIM exception %s %s", type(e).__name__, str(e))
- failed_message = str(e)
- if failed:
- for net in net_list[datacenter_key]:
- net_dict[net] = {'status': "VIM_ERROR", 'error_msg': failed_message}
-
- # 4. Update the status of nets in the instanceDict, while collects the nets whose status changed
- # TODO: update nets inside a vnf
- for net in instanceDict['nets']:
- net_id = net['vim_net_id']
- if net_dict[net_id].get('error_msg') and len(net_dict[net_id]['error_msg']) >= 1024:
- net_dict[net_id]['error_msg'] = net_dict[net_id]['error_msg'][:516] + " ... " + net_dict[vm_id]['error_msg'][-500:]
- if net['status'] != net_dict[net_id]['status'] or net.get('error_msg')!=net_dict[net_id].get('error_msg') or net.get('vim_info')!=net_dict[net_id].get('vim_info'):
- net['status'] = net_dict[net_id]['status']
- net['error_msg'] = net_dict[net_id].get('error_msg')
- net['vim_info'] = net_dict[net_id].get('vim_info')
- # 5.1. Update in openmano DB the nets whose status changed
- try:
- updated = mydb.update_rows('instance_nets', UPDATE=net_dict[net_id], WHERE={'uuid':net["uuid"]})
- nets_notupdated.remove(net["uuid"])
- if updated>0:
- nets_updated.append(net["uuid"])
- except db_base_Exception as e:
- logger.error("nfvo.refresh_instance error database update: %s", str(e))
-
- # 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))
+ # # 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={}
+ #
+ # # 1. Getting VIM vm and net list
+ # vms_updated = [] #List of VM instance uuids in openmano that were updated
+ # vms_notupdated=[]
+ # vm_list = {}
+ # for sce_vnf in instanceDict['vnfs']:
+ # datacenter_key = (sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"])
+ # if datacenter_key not in vm_list:
+ # vm_list[datacenter_key] = []
+ # if datacenter_key not in myvims:
+ # vims = get_vim(mydb, nfvo_tenant, datacenter_id=sce_vnf["datacenter_id"],
+ # datacenter_tenant_id=sce_vnf["datacenter_tenant_id"])
+ # if len(vims) == 0:
+ # logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(sce_vnf["datacenter_id"], sce_vnf["datacenter_tenant_id"]))
+ # myvims[datacenter_key] = None
+ # else:
+ # myvims[datacenter_key] = vims.values()[0]
+ # for vm in sce_vnf['vms']:
+ # vm_list[datacenter_key].append(vm['vim_vm_id'])
+ # vms_notupdated.append(vm["uuid"])
+ #
+ # nets_updated = [] #List of VM instance uuids in openmano that were updated
+ # nets_notupdated=[]
+ # net_list = {}
+ # for net in instanceDict['nets']:
+ # datacenter_key = (net["datacenter_id"], net["datacenter_tenant_id"])
+ # if datacenter_key not in net_list:
+ # net_list[datacenter_key] = []
+ # if datacenter_key not in myvims:
+ # vims = get_vim(mydb, nfvo_tenant, datacenter_id=net["datacenter_id"],
+ # datacenter_tenant_id=net["datacenter_tenant_id"])
+ # if len(vims) == 0:
+ # logger.error("datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"]))
+ # myvims[datacenter_key] = None
+ # else:
+ # myvims[datacenter_key] = vims.values()[0]
+ #
+ # net_list[datacenter_key].append(net['vim_net_id'])
+ # nets_notupdated.append(net["uuid"])
+ #
+ # # 1. Getting the status of all VMs
+ # vm_dict={}
+ # for datacenter_key in myvims:
+ # if not vm_list.get(datacenter_key):
+ # continue
+ # failed = True
+ # failed_message=""
+ # if not myvims[datacenter_key]:
+ # failed_message = "datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"])
+ # else:
+ # try:
+ # vm_dict.update(myvims[datacenter_key].refresh_vms_status(vm_list[datacenter_key]) )
+ # failed = False
+ # except vimconn.vimconnException as e:
+ # logger.error("VIM exception %s %s", type(e).__name__, str(e))
+ # failed_message = str(e)
+ # if failed:
+ # for vm in vm_list[datacenter_key]:
+ # vm_dict[vm] = {'status': "VIM_ERROR", 'error_msg': failed_message}
+ #
+ # # 2. Update the status of VMs in the instanceDict, while collects the VMs whose status changed
+ # for sce_vnf in instanceDict['vnfs']:
+ # for vm in sce_vnf['vms']:
+ # vm_id = vm['vim_vm_id']
+ # interfaces = vm_dict[vm_id].pop('interfaces', [])
+ # #2.0 look if contain manamgement interface, and if not change status from ACTIVE:NoMgmtIP to ACTIVE
+ # has_mgmt_iface = False
+ # for iface in vm["interfaces"]:
+ # if iface["type"]=="mgmt":
+ # has_mgmt_iface = True
+ # if vm_dict[vm_id]['status'] == "ACTIVE:NoMgmtIP" and not has_mgmt_iface:
+ # vm_dict[vm_id]['status'] = "ACTIVE"
+ # if vm_dict[vm_id].get('error_msg') and len(vm_dict[vm_id]['error_msg']) >= 1024:
+ # vm_dict[vm_id]['error_msg'] = vm_dict[vm_id]['error_msg'][:516] + " ... " + vm_dict[vm_id]['error_msg'][-500:]
+ # if vm['status'] != vm_dict[vm_id]['status'] or vm.get('error_msg')!=vm_dict[vm_id].get('error_msg') or vm.get('vim_info')!=vm_dict[vm_id].get('vim_info'):
+ # vm['status'] = vm_dict[vm_id]['status']
+ # vm['error_msg'] = vm_dict[vm_id].get('error_msg')
+ # vm['vim_info'] = vm_dict[vm_id].get('vim_info')
+ # # 2.1. Update in openmano DB the VMs whose status changed
+ # try:
+ # updates = mydb.update_rows('instance_vms', UPDATE=vm_dict[vm_id], WHERE={'uuid':vm["uuid"]})
+ # vms_notupdated.remove(vm["uuid"])
+ # if updates>0:
+ # vms_updated.append(vm["uuid"])
+ # except db_base_Exception as e:
+ # logger.error("nfvo.refresh_instance error database update: %s", str(e))
+ # # 2.2. Update in openmano DB the interface VMs
+ # for interface in interfaces:
+ # #translate from vim_net_id to instance_net_id
+ # network_id_list=[]
+ # for net in instanceDict['nets']:
+ # if net["vim_net_id"] == interface["vim_net_id"]:
+ # network_id_list.append(net["uuid"])
+ # if not network_id_list:
+ # continue
+ # del interface["vim_net_id"]
+ # try:
+ # for network_id in network_id_list:
+ # mydb.update_rows('instance_interfaces', UPDATE=interface, WHERE={'instance_vm_id':vm["uuid"], "instance_net_id":network_id})
+ # except db_base_Exception as e:
+ # logger.error( "nfvo.refresh_instance error with vm=%s, interface_net_id=%s", vm["uuid"], network_id)
+ #
+ # # 3. Getting the status of all nets
+ # net_dict = {}
+ # for datacenter_key in myvims:
+ # if not net_list.get(datacenter_key):
+ # continue
+ # failed = True
+ # failed_message = ""
+ # if not myvims[datacenter_key]:
+ # failed_message = "datacenter '{}' with datacenter_tenant_id '{}' not found".format(net["datacenter_id"], net["datacenter_tenant_id"])
+ # else:
+ # try:
+ # net_dict.update(myvims[datacenter_key].refresh_nets_status(net_list[datacenter_key]) )
+ # failed = False
+ # except vimconn.vimconnException as e:
+ # logger.error("VIM exception %s %s", type(e).__name__, str(e))
+ # failed_message = str(e)
+ # if failed:
+ # for net in net_list[datacenter_key]:
+ # net_dict[net] = {'status': "VIM_ERROR", 'error_msg': failed_message}
+ #
+ # # 4. Update the status of nets in the instanceDict, while collects the nets whose status changed
+ # # TODO: update nets inside a vnf
+ # for net in instanceDict['nets']:
+ # net_id = net['vim_net_id']
+ # if net_dict[net_id].get('error_msg') and len(net_dict[net_id]['error_msg']) >= 1024:
+ # net_dict[net_id]['error_msg'] = net_dict[net_id]['error_msg'][:516] + " ... " + net_dict[vm_id]['error_msg'][-500:]
+ # if net['status'] != net_dict[net_id]['status'] or net.get('error_msg')!=net_dict[net_id].get('error_msg') or net.get('vim_info')!=net_dict[net_id].get('vim_info'):
+ # net['status'] = net_dict[net_id]['status']
+ # net['error_msg'] = net_dict[net_id].get('error_msg')
+ # net['vim_info'] = net_dict[net_id].get('vim_info')
+ # # 5.1. Update in openmano DB the nets whose status changed
+ # try:
+ # updated = mydb.update_rows('instance_nets', UPDATE=net_dict[net_id], WHERE={'uuid':net["uuid"]})
+ # nets_notupdated.remove(net["uuid"])
+ # if updated>0:
+ # nets_updated.append(net["uuid"])
+ # except db_base_Exception as e:
+ # logger.error("nfvo.refresh_instance error database update: %s", str(e))
+ #
+ # # 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))
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
+ # 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)
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)
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
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)
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)
if new_config_dict[k]==None:
to_delete.append(k)
- config_dict = yaml.load(datacenter["config"])
+ config_text = datacenter.get("config")
+ if not config_text:
+ config_text = '{}'
+ config_dict = yaml.load(config_text)
config_dict.update(new_config_dict)
#delete null fields
for k in to_delete:
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)
# 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, thread_name)
+ new_thread = vim_thread.vim_thread(myvim, task_lock, thread_name, datacenter_name, db=db, db_lock=db_lock, ovim=ovim)
new_thread.start()
- vim_threads["running"][datacenter_id + "-" + tenant_dict['uuid']] = new_thread
+ thread_id = datacenter_tenants_dict["uuid"]
+ vim_threads["running"][thread_id] = new_thread
+ return datacenter_id
+
+def edit_datacenter_to_tenant(mydb, nfvo_tenant, datacenter_id, vim_tenant_id=None, vim_tenant_name=None, vim_username=None, vim_password=None, config=None):
+ #Obtain the data of this datacenter_tenant_id
+ vim_data = mydb.get_rows(
+ SELECT=("datacenter_tenants.vim_tenant_name", "datacenter_tenants.vim_tenant_id", "datacenter_tenants.user",
+ "datacenter_tenants.passwd", "datacenter_tenants.config"),
+ FROM="datacenter_tenants JOIN tenants_datacenters ON datacenter_tenants.uuid=tenants_datacenters.datacenter_tenant_id",
+ WHERE={"tenants_datacenters.nfvo_tenant_id": nfvo_tenant,
+ "tenants_datacenters.datacenter_id": datacenter_id})
+
+ logger.debug(str(vim_data))
+ if len(vim_data) < 1:
+ raise NfvoException("Datacenter {} is not attached for tenant {}".format(datacenter_id, nfvo_tenant), HTTP_Conflict)
+
+ v = vim_data[0]
+ if v['config']:
+ v['config'] = yaml.load(v['config'])
+
+ if vim_tenant_id:
+ v['vim_tenant_id'] = vim_tenant_id
+ if vim_tenant_name:
+ v['vim_tenant_name'] = vim_tenant_name
+ if vim_username:
+ v['user'] = vim_username
+ if vim_password:
+ v['passwd'] = vim_password
+ if config:
+ if not v['config']:
+ v['config'] = {}
+ v['config'].update(config)
+
+ logger.debug(str(v))
+ deassociate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter_id, vim_tenant_id=v['vim_tenant_id'])
+ associate_datacenter_to_tenant(mydb, nfvo_tenant, datacenter_id, vim_tenant_id=v['vim_tenant_id'], vim_tenant_name=v['vim_tenant_name'],
+ vim_username=v['user'], vim_password=v['passwd'], config=v['config'])
return datacenter_id
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
- thread_id = datacenter_id + "-" + tenant_datacenter_item["nfvo_tenant_id"]
+ thread_id = tenant_datacenter_item["datacenter_tenant_id"]
thread = vim_threads["running"][thread_id]
- thread.insert_task("exit")
+ thread.insert_task(new_task("exit", None))
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
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)
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)
net_list.append(net_nfvo)
return net_list
+
def vim_action_get(mydb, tenant_id, datacenter, item, name):
#get datacenter info
datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
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":
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"))
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)
+
+def sdn_controller_create(mydb, tenant_id, sdn_controller):
+ data = ovim.new_of_controller(sdn_controller)
+ logger.debug('New SDN controller created with uuid {}'.format(data))
+ return data
+
+def sdn_controller_update(mydb, tenant_id, controller_id, sdn_controller):
+ data = ovim.edit_of_controller(controller_id, sdn_controller)
+ msg = 'SDN controller {} updated'.format(data)
+ logger.debug(msg)
+ return msg
+
+def sdn_controller_list(mydb, tenant_id, controller_id=None):
+ if controller_id == None:
+ data = ovim.get_of_controllers()
+ else:
+ data = ovim.show_of_controller(controller_id)
+
+ msg = 'SDN controller list:\n {}'.format(data)
+ logger.debug(msg)
+ return data
+
+def sdn_controller_delete(mydb, tenant_id, controller_id):
+ select_ = ('uuid', 'config')
+ datacenters = mydb.get_rows(FROM='datacenters', SELECT=select_)
+ for datacenter in datacenters:
+ if datacenter['config']:
+ config = yaml.load(datacenter['config'])
+ if 'sdn-controller' in config and config['sdn-controller'] == controller_id:
+ raise NfvoException("SDN controller {} is in use by datacenter {}".format(controller_id, datacenter['uuid']), HTTP_Conflict)
+
+ data = ovim.delete_of_controller(controller_id)
+ msg = 'SDN controller {} deleted'.format(data)
+ logger.debug(msg)
+ return msg
+
+def datacenter_sdn_port_mapping_set(mydb, tenant_id, datacenter_id, sdn_port_mapping):
+ controller = mydb.get_rows(FROM="datacenters", SELECT=("config",), WHERE={"uuid":datacenter_id})
+ if len(controller) < 1:
+ raise NfvoException("Datacenter {} not present in the database".format(datacenter_id), HTTP_Not_Found)
+
+ try:
+ sdn_controller_id = yaml.load(controller[0]["config"])["sdn-controller"]
+ except:
+ raise NfvoException("The datacenter {} has not an SDN controller associated".format(datacenter_id), HTTP_Bad_Request)
+
+ sdn_controller = ovim.show_of_controller(sdn_controller_id)
+ switch_dpid = sdn_controller["dpid"]
+
+ maps = list()
+ for compute_node in sdn_port_mapping:
+ #element = {"ofc_id": sdn_controller_id, "region": datacenter_id, "switch_dpid": switch_dpid}
+ element = dict()
+ element["compute_node"] = compute_node["compute_node"]
+ for port in compute_node["ports"]:
+ element["pci"] = port.get("pci")
+ element["switch_port"] = port.get("switch_port")
+ element["switch_mac"] = port.get("switch_mac")
+ if not element["pci"] or not (element["switch_port"] or element["switch_mac"]):
+ raise NfvoException ("The mapping must contain the 'pci' and at least one of the elements 'switch_port'"
+ " or 'switch_mac'", HTTP_Bad_Request)
+ maps.append(dict(element))
+
+ return ovim.set_of_port_mapping(maps, ofc_id=sdn_controller_id, switch_dpid=switch_dpid, region=datacenter_id)
+
+def datacenter_sdn_port_mapping_list(mydb, tenant_id, datacenter_id):
+ maps = ovim.get_of_port_mappings(db_filter={"region": datacenter_id})
+
+ result = {
+ "sdn-controller": None,
+ "datacenter-id": datacenter_id,
+ "dpid": None,
+ "ports_mapping": list()
+ }
+
+ datacenter = mydb.get_table_by_uuid_name('datacenters', datacenter_id)
+ if datacenter['config']:
+ config = yaml.load(datacenter['config'])
+ if 'sdn-controller' in config:
+ controller_id = config['sdn-controller']
+ sdn_controller = sdn_controller_list(mydb, tenant_id, controller_id)
+ result["sdn-controller"] = controller_id
+ result["dpid"] = sdn_controller["dpid"]
+
+ if result["sdn-controller"] == None or result["dpid"] == None:
+ raise NfvoException("Not all SDN controller information for datacenter {} could be found: {}".format(datacenter_id, result),
+ HTTP_Internal_Server_Error)
+
+ if len(maps) == 0:
+ return result
+
+ ports_correspondence_dict = dict()
+ for link in maps:
+ if result["sdn-controller"] != link["ofc_id"]:
+ raise NfvoException("The sdn-controller specified for different port mappings differ", HTTP_Internal_Server_Error)
+ if result["dpid"] != link["switch_dpid"]:
+ raise NfvoException("The dpid specified for different port mappings differ", HTTP_Internal_Server_Error)
+ element = dict()
+ element["pci"] = link["pci"]
+ if link["switch_port"]:
+ element["switch_port"] = link["switch_port"]
+ if link["switch_mac"]:
+ element["switch_mac"] = link["switch_mac"]
+
+ if not link["compute_node"] in ports_correspondence_dict:
+ content = dict()
+ content["compute_node"] = link["compute_node"]
+ content["ports"] = list()
+ ports_correspondence_dict[link["compute_node"]] = content
+
+ ports_correspondence_dict[link["compute_node"]]["ports"].append(element)
+
+ for key in sorted(ports_correspondence_dict):
+ result["ports_mapping"].append(ports_correspondence_dict[key])
+
+ return result
+
+def datacenter_sdn_port_mapping_delete(mydb, tenant_id, datacenter_id):
+ return ovim.clear_of_port_mapping(db_filter={"region":datacenter_id})
\ No newline at end of file
projects / osm / RO.git / blobdiff