from osm_ro.utils import deprecated
from osm_ro.vim_thread import vim_thread
import osm_ro.console_proxy_thread as cli
-from osm_ro import vimconn
+from osm_ro_plugin.vim_dummy import VimDummyConnector
+from osm_ro_plugin.sdn_dummy import SdnDummyConnector
+from osm_ro_plugin.sdn_failing import SdnFailingConnector
+from osm_ro_plugin import vimconn, sdnconn
import logging
import collections
import math
from osm_ro import nfvo_db
from threading import Lock
import time as t
-# TODO py3 BEGIN
from osm_ro.sdn import Sdn, SdnException as ovimException
-# from lib_osm_openvim.ovim import ovimException
-# from unittest.mock import MagicMock
-# class ovimException(Exception):
-# pass
-# TODO py3 END
from Crypto.PublicKey import RSA
# WIM
-from .wim import sdnconn
-from .wim.wimconn_dummy import DummyConnector
-from .wim.failing_connector import FailingConnector
from .http_tools import errors as httperrors
from .wim.engine import WimEngine
from .wim.persistence import WimPersistence
except Exception as e:
logger.critical("Cannot load osm_{}: {}".format(name, e))
if name:
- plugins[name] = FailingConnector("Cannot load osm_{}: {}".format(name, e))
+ plugins[name] = SdnFailingConnector("Cannot load osm_{}: {}".format(name, e))
if name and name not in plugins:
error_text = "Cannot load a module for {t} type '{n}'. The plugin 'osm_{n}' has not been" \
" registered".format(t=type, n=name)
logger.critical(error_text)
- plugins[name] = FailingConnector(error_text)
+ plugins[name] = SdnFailingConnector(error_text)
# raise NfvoException("Cannot load a module for {t} type '{n}'. The plugin 'osm_{n}' has not been registered".
# format(t=type, n=name), httperrors.Bad_Request)
# Try getting docker id. If fails, get pid
try:
with open("/proc/self/cgroup", "r") as f:
- text_id_ = f.readline()
- _, _, text_id = text_id_.rpartition("/")
- text_id = text_id.replace("\n", "")[:12]
- if text_id:
- return text_id
+ for text_id_ in f.readlines():
+ if "docker/" not in text_id_:
+ continue
+ _, _, text_id = text_id_.rpartition("/")
+ text_id = text_id.replace("\n", "")[:12]
+ if text_id:
+ return text_id
except Exception:
pass
# Return a random id
try:
worker_id = get_process_id()
if "rosdn_dummy" not in plugins:
- plugins["rosdn_dummy"] = DummyConnector
+ plugins["rosdn_dummy"] = SdnDummyConnector
+ if "rovim_dummy" not in plugins:
+ plugins["rovim_dummy"] = VimDummyConnector
# starts ovim library
ovim = Sdn(db, plugins)
try:
#if not tenant:
# return -httperrors.Bad_Request, "You must provide a valid tenant name or uuid for VIM %s" % ( vim["type"])
- myvim = plugins[plugin_name].vimconnector(
+ myvim = plugins[plugin_name](
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 vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
myvim = e
logger.error("Cannot launch thread for VIM {} '{}': {}".format(vim['datacenter_name'],
vim['datacenter_id'], e))
persistent_info = {}
#if not tenant:
# return -httperrors.Bad_Request, "You must provide a valid tenant name or uuid for VIM %s" % ( vim["type"])
- vim_dict[vim['datacenter_id']] = plugins[plugin_name].vimconnector(
+ vim_dict[vim['datacenter_id']] = plugins[plugin_name](
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),
logger.error("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, str(e)))
continue
http_code = httperrors.Internal_Server_Error
- if isinstance(e, vimconn.vimconnException):
+ if isinstance(e, vimconn.VimConnException):
http_code = e.http_code
raise NfvoException("Error at VIM {}; {}: {}".format(vim["type"], type(e).__name__, str(e)), http_code)
return vim_dict
vim.delete_network(item["uuid"])
elif item["what"]=="vm":
vim.delete_vminstance(item["uuid"])
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
logger.error("Error in rollback. Not possible to delete VIM %s '%s'. Message: %s", item['what'], item["uuid"], str(e))
undeleted_items.append("{} {} from VIM {}".format(item['what'], item["uuid"], vim["name"]))
except db_base_Exception as e:
vim_images = vim.get_image_list(filter_dict)
#logger.debug('>>>>>>>> VIM images: %s', str(vim_images))
if len(vim_images) > 1:
- raise vimconn.vimconnException("More than one candidate VIM image found for filter: {}".format(str(filter_dict)), httperrors.Conflict)
+ raise vimconn.VimConnException("More than one candidate VIM image found for filter: {}".format(str(filter_dict)), httperrors.Conflict)
elif len(vim_images) == 0:
- raise vimconn.vimconnNotFoundException("Image not found at VIM with filter: '{}'".format(str(filter_dict)))
+ raise vimconn.VimConnNotFoundException("Image not found at VIM with filter: '{}'".format(str(filter_dict)))
else:
#logger.debug('>>>>>>>> VIM image 0: %s', str(vim_images[0]))
image_vim_id = vim_images[0]['id']
- except vimconn.vimconnNotFoundException as e:
+ except vimconn.VimConnNotFoundException as e:
#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
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:
+ raise vimconn.VimConnException(str(e))
+ except vimconn.VimConnException as e:
if return_on_error:
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': %s", vim["name"], str(e))
continue
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
if return_on_error:
logger.error("Error contacting VIM to know if the image exists at VIM: %s", str(e))
raise
try:
vim.get_flavor(flavor_vim_id)
continue #flavor exist
- except vimconn.vimconnException:
+ except vimconn.VimConnException:
pass
#create flavor at vim
logger.debug("nfvo.create_or_use_flavor() adding flavor to VIM %s", vim["name"])
flavor_vim_id = None
flavor_vim_id=vim.get_flavor_id_from_data(flavor_dict)
flavor_created="false"
- except vimconn.vimconnException as e:
+ 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:
+ except vimconn.VimConnException as e:
if return_on_error:
logger.error("Error creating flavor at VIM %s: %s.", vim["name"], str(e))
raise
# 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
- except (db_base_Exception, vimconn.vimconnException, KeyError) as e:
+ except (db_base_Exception, vimconn.VimConnException, KeyError) as e:
_, message = rollback(mydb, vims, rollback_list)
if isinstance(e, db_base_Exception):
error_text = "Exception at database"
# 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
- except (db_base_Exception, vimconn.vimconnException, KeyError) as e:
+ except (db_base_Exception, vimconn.VimConnException, KeyError) as e:
_, message = rollback(mydb, vims, rollback_list)
if isinstance(e, db_base_Exception):
error_text = "Exception at database"
continue
try:
myvim.delete_flavor(flavor_vim["vim_id"])
- except vimconn.vimconnNotFoundException:
+ except vimconn.VimConnNotFoundException:
logger.warn("VIM flavor %s not exist at datacenter %s", flavor_vim["vim_id"],
flavor_vim["datacenter_vim_id"] )
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
logger.error("Not possible to delete VIM flavor %s from datacenter %s: %s %s",
flavor_vim["vim_id"], flavor_vim["datacenter_vim_id"], type(e).__name__, str(e))
undeletedItems.append("flavor {} from VIM {}".format(flavor_vim["vim_id"],
myvim=vims[ image_vim["datacenter_id"] ]
try:
myvim.delete_image(image_vim["vim_id"])
- except vimconn.vimconnNotFoundException as e:
+ except vimconn.VimConnNotFoundException as e:
logger.warn("VIM image %s not exist at datacenter %s", image_vim["vim_id"], image_vim["datacenter_id"] )
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
logger.error("Not possible to delete VIM image %s from datacenter %s: %s %s",
image_vim["vim_id"], image_vim["datacenter_id"], type(e).__name__, str(e))
undeletedItems.append("image {} from VIM {}".format(image_vim["vim_id"], image_vim["datacenter_id"] ))
#print 'datacenters '+ json.dumps(datacenter, indent=4)
return datacenter
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
raise NfvoException("Not possible to get_host_list from VIM: {}".format(str(e)), e.http_code)
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:
+ except (db_base_Exception, vimconn.VimConnException) as e:
_, message = rollback(mydb, vims, rollbackList)
if isinstance(e, db_base_Exception):
error_text = "Exception at database"
def get_vim_thread(mydb, tenant_id, datacenter_id_name=None, datacenter_tenant_id=None):
+ global plugins
datacenter_id = None
datacenter_name = None
thread = None
if datacenter_tenant_id:
where_["dt.uuid"] = datacenter_tenant_id
datacenters = mydb.get_rows(
- SELECT=("dt.uuid as datacenter_tenant_id, d.name as datacenter_name",),
+ SELECT=("dt.uuid as datacenter_tenant_id, d.name as datacenter_name", "d.type as type"),
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_)
datacenter_name = datacenters[0]["datacenter_name"]
thread = vim_threads["running"].get(thread_id)
if not thread:
+ datacenter_type = datacenters[0]["type"]
+ plugin_name = "rovim_" + datacenter_type
+ if plugin_name not in plugins:
+ _load_plugin(plugin_name, type="vim")
thread_name = get_non_used_vim_name(datacenter_name, datacenter_id)
thread = vim_thread(task_lock, plugins, thread_name, None,
thread_id, db=mydb)
" dt on td.datacenter_tenant_id=dt.uuid"
else:
from_ = 'datacenters as d'
- vimaccounts = mydb.get_rows(FROM=from_, SELECT=("d.uuid as uuid, d.name as name",), WHERE=WHERE_dict )
+ vimaccounts = mydb.get_rows(FROM=from_, SELECT=("d.uuid as uuid", "d.name as name", "d.type as type"),
+ WHERE=WHERE_dict)
if len(vimaccounts) == 0:
raise NfvoException("datacenter '{}' not found".format(str(datacenter_id_name)), httperrors.Not_Found)
- elif len(vimaccounts)>1:
- #print "nfvo.datacenter_action() error. Several datacenters found"
+ elif len(vimaccounts) > 1:
+ # print "nfvo.datacenter_action() error. Several datacenters found"
raise NfvoException("More than one datacenters found, try to identify with uuid", httperrors.Conflict)
- return vimaccounts[0]["uuid"], vimaccounts[0]["name"]
+ return vimaccounts[0]["uuid"], vimaccounts[0]
def get_datacenter_by_name_uuid(mydb, tenant_id, datacenter_id_name=None, **extra_filter):
involved_datacenters.append(default_datacenter_id)
target_wim_account = sce_net.get("wim_account", default_wim_account)
- # --> WIM
- # TODO: use this information during network creation
- wim_account_id = wim_account_name = None
- if len(involved_datacenters) > 1 and 'uuid' in sce_net:
- if target_wim_account is None or target_wim_account is True: # automatic selection of WIM
- # OBS: sce_net without uuid are used internally to VNFs
- # and the assumption is that VNFs will not be split among
- # different datacenters
- wim_account = wim_engine.find_suitable_wim_account(
- involved_datacenters, tenant_id)
- wim_account_id = wim_account['uuid']
- wim_account_name = wim_account['name']
- wim_usage[sce_net['uuid']] = wim_account_id
- elif isinstance(target_wim_account, str): # manual selection of WIM
- wim_account.persist.get_wim_account_by(target_wim_account, tenant_id)
- wim_account_id = wim_account['uuid']
- wim_account_name = wim_account['name']
- wim_usage[sce_net['uuid']] = wim_account_id
- else: # not WIM usage
- wim_usage[sce_net['uuid']] = False
- # <-- WIM
-
descriptor_net = {}
if instance_dict.get("networks"):
if sce_net.get("uuid") in instance_dict["networks"]:
)
if not target_instance_nets:
raise NfvoException(
- "Cannot find the target network at instance:networks[{}]:use-network".format(descriptor_net_name),
- httperrors.Bad_Request)
+ "Cannot find the target network at instance:networks[{}]:use-network".format(
+ descriptor_net_name), httperrors.Bad_Request)
else:
use_network = target_instance_nets[0]["related"]
if sce_net["external"]:
number_mgmt_networks += 1
+ # --> WIM
+ # TODO: use this information during network creation
+ wim_account_id = wim_account_name = None
+ if len(involved_datacenters) > 1 and 'uuid' in sce_net:
+ urls = [myvims[v].url for v in involved_datacenters]
+ if len(set(urls)) < 2:
+ wim_usage[sce_net['uuid']] = False
+ elif target_wim_account is None or target_wim_account is True: # automatic selection of WIM
+ # OBS: sce_net without uuid are used internally to VNFs
+ # and the assumption is that VNFs will not be split among
+ # different datacenters
+ wim_account = wim_engine.find_suitable_wim_account(
+ involved_datacenters, tenant_id)
+ wim_account_id = wim_account['uuid']
+ wim_account_name = wim_account['name']
+ wim_usage[sce_net['uuid']] = wim_account_id
+ elif isinstance(target_wim_account, str): # manual selection of WIM
+ wim_account.persist.get_wim_account_by(target_wim_account, tenant_id)
+ wim_account_id = wim_account['uuid']
+ wim_account_name = wim_account['name']
+ wim_usage[sce_net['uuid']] = wim_account_id
+ else: # not WIM usage
+ wim_usage[sce_net['uuid']] = False
+ # <-- WIM
+
for datacenter_id in involved_datacenters:
netmap_use = None
netmap_create = None
returned_instance = mydb.get_instance_scenario(instance_uuid)
returned_instance["action_id"] = instance_action_id
return returned_instance
- except (NfvoException, vimconn.vimconnException, sdnconn.SdnConnectorError, db_base_Exception) as e:
+ except (NfvoException, vimconn.VimConnException, sdnconn.SdnConnectorError, db_base_Exception) as e:
message = rollback(mydb, myvims, rollbackList)
if isinstance(e, db_base_Exception):
error_text = "database Exception"
- elif isinstance(e, vimconn.vimconnException):
+ elif isinstance(e, vimconn.VimConnException):
error_text = "VIM Exception"
elif isinstance(e, sdnconn.SdnConnectorError):
error_text = "WIM Exception"
# try:
# vm_dict.update(myvims[datacenter_key].refresh_vms_status(vm_list[datacenter_key]) )
# failed = False
- # except vimconn.vimconnException as e:
+ # except vimconn.VimConnException as e:
# logger.error("VIM exception %s %s", type(e).__name__, str(e))
# failed_message = str(e)
# if failed:
# try:
# net_dict.update(myvims[datacenter_key].refresh_nets_status(net_list[datacenter_key]) )
# failed = False
- # except vimconn.vimconnException as e:
+ # except vimconn.VimConnException as e:
# logger.error("VIM exception %s %s", type(e).__name__, str(e))
# failed_message = str(e)
# if failed:
else:
vm_result[ vm['uuid'] ] = {"vim_result": 200, "description": "ok", "name":vm['name']}
vm_ok +=1
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
vm_result[ vm['uuid'] ] = {"vim_result": e.http_code, "name":vm['name'], "description": str(e)}
vm_error+=1
def create_vim_account(mydb, nfvo_tenant, datacenter_id, name=None, vim_id=None, vim_tenant=None, vim_tenant_name=None,
vim_username=None, vim_password=None, config=None):
+ global plugins
# get datacenter info
try:
if not datacenter_id:
if not vim_id:
raise NfvoException("You must provide 'vim_id", http_code=httperrors.Bad_Request)
datacenter_id = vim_id
- datacenter_id, datacenter_name = get_datacenter_uuid(mydb, None, datacenter_id)
+ datacenter_id, datacenter = get_datacenter_uuid(mydb, None, datacenter_id)
+ datacenter_name = datacenter["name"]
+ datacenter_type = datacenter["type"]
create_vim_tenant = True if not vim_tenant 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']
+ if vim_tenant_name is None:
+ vim_tenant_name = tenant_dict['name']
- tenants_datacenter_dict={"nfvo_tenant_id":tenant_dict['uuid'], "datacenter_id":datacenter_id }
+ tenants_datacenter_dict = {"nfvo_tenant_id": tenant_dict['uuid'], "datacenter_id": datacenter_id}
# #check that this association does not exist before
# tenants_datacenters = mydb.get_rows(FROM='tenants_datacenters', WHERE=tenants_datacenter_dict)
# if len(tenants_datacenters)>0:
- # raise NfvoException("datacenter '{}' and tenant'{}' are already attached".format(datacenter_id, tenant_dict['uuid']), httperrors.Conflict)
+ # raise NfvoException("datacenter '{}' and tenant'{}' are already attached".format(
+ # datacenter_id, tenant_dict['uuid']), httperrors.Conflict)
- vim_tenant_id_exist_atdb=False
+ vim_tenant_id_exist_atdb = False
if not create_vim_tenant:
where_={"datacenter_id": datacenter_id}
- if vim_tenant!=None:
+ if vim_tenant is not None:
where_["vim_tenant_id"] = vim_tenant
- if vim_tenant_name!=None:
+ if vim_tenant_name is not None:
where_["vim_tenant_name"] = vim_tenant_name
- #check if vim_tenant_id is already at database
+ # check if vim_tenant_id is already at database
datacenter_tenants_dict = mydb.get_rows(FROM='datacenter_tenants', WHERE=where_)
- if len(datacenter_tenants_dict)>=1:
+ if len(datacenter_tenants_dict) >= 1:
datacenter_tenants_dict = datacenter_tenants_dict[0]
- vim_tenant_id_exist_atdb=True
- #TODO check if a field has changed and edit entry at datacenter_tenants at DB
- else: #result=0
+ vim_tenant_id_exist_atdb = True
+ # TODO check if a field has changed and edit entry at datacenter_tenants at DB
+ else: # result=0
datacenter_tenants_dict = {}
- #insert at table datacenter_tenants
- else: #if vim_tenant==None:
- #create tenant at VIM if not provided
+ # insert at table datacenter_tenants
+ else: # if vim_tenant==None:
+ # create tenant at VIM if not provided
try:
- _, myvim = get_datacenter_by_name_uuid(mydb, None, datacenter, vim_user=vim_username,
- vim_passwd=vim_password)
+ _, myvim = get_datacenter_by_name_uuid(mydb, None, datacenter_id, vim_user=vim_username,
+ vim_passwd=vim_password)
datacenter_name = myvim["name"]
vim_tenant = myvim.new_tenant(vim_tenant_name, "created by openmano for datacenter "+datacenter_name)
- except vimconn.vimconnException as e:
- raise NfvoException("Not possible to create vim_tenant {} at VIM: {}".format(vim_tenant_id, str(e)), httperrors.Internal_Server_Error)
- datacenter_tenants_dict = {}
- datacenter_tenants_dict["created"]="true"
+ except vimconn.VimConnException as e:
+ raise NfvoException("Not possible to create vim_tenant {} at VIM: {}".format(vim_tenant_name, e),
+ httperrors.Internal_Server_Error)
+ datacenter_tenants_dict = {"created": "true"}
- #fill datacenter_tenants table
+ # fill datacenter_tenants table
if not vim_tenant_id_exist_atdb:
datacenter_tenants_dict["vim_tenant_id"] = vim_tenant
datacenter_tenants_dict["vim_tenant_name"] = vim_tenant_name
id_ = mydb.new_row('datacenter_tenants', datacenter_tenants_dict, add_uuid=True, confidential_data=True)
datacenter_tenants_dict["uuid"] = id_
- #fill tenants_datacenters table
+ # fill tenants_datacenters table
datacenter_tenant_id = datacenter_tenants_dict["uuid"]
tenants_datacenter_dict["datacenter_tenant_id"] = datacenter_tenant_id
mydb.new_row('tenants_datacenters', tenants_datacenter_dict)
- # create thread
+ # load plugin and create thread
+ plugin_name = "rovim_" + datacenter_type
+ if plugin_name not in plugins:
+ _load_plugin(plugin_name, type="vim")
thread_name = get_non_used_vim_name(datacenter_name, datacenter_id)
new_thread = vim_thread(task_lock, plugins, thread_name, None, datacenter_tenant_id, db=db)
new_thread.start()
thread_id = datacenter_tenants_dict["uuid"]
vim_threads["running"][thread_id] = new_thread
return thread_id
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
raise NfvoException(str(e), httperrors.Bad_Request)
try:
datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
myvim.delete_tenant(vim_tenant_dict['vim_tenant_id'])
- except vimconn.vimconnException as e:
+ 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:
if 'check-connectivity' in action_dict:
try:
myvim.check_vim_connectivity()
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
#logger.error("nfvo.datacenter_action() Not possible to get_network_list from VIM: %s ", str(e))
raise NfvoException(str(e), e.http_code)
elif 'net-update' in action_dict:
try:
nets = myvim.get_network_list(filter_dict={'shared': True, 'admin_state_up': True, 'status': 'ACTIVE'})
#print content
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
#logger.error("nfvo.datacenter_action() Not possible to get_network_list from VIM: %s ", str(e))
raise NfvoException(str(e), httperrors.Internal_Server_Error)
#update nets Change from VIM format to NFVO format
try:
vim_nets = myvim.get_network_list(filter_dict=filter_dict)
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
#logger.error("nfvo.datacenter_new_netmap() Not possible to get_network_list from VIM: %s ", str(e))
raise NfvoException(str(e), httperrors.Internal_Server_Error)
if len(vim_nets)>1 and action_dict:
datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter)
network = myvim.get_network_list(filter_dict=filter_dict)
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
raise NfvoException("Not possible to get_sdn_net_id from VIM: {}".format(str(e)), e.http_code)
# ensure the network is defined
datacenter)
else:
return {item: content}
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
print("vim_action Not possible to get_{}_list from VIM: {} ".format(item, str(e)))
raise NfvoException("Not possible to get_{}_list from VIM: {}".format(item, str(e)), e.http_code)
content = myvim.delete_image(item_id)
else:
raise NfvoException(item + "?", httperrors.Method_Not_Allowed)
- except vimconn.vimconnException as e:
+ 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)
content = myvim.new_tenant(tenant["name"], tenant.get("description"))
else:
raise NfvoException(item + "?", httperrors.Method_Not_Allowed)
- except vimconn.vimconnException as e:
+ 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)