scenario_action_schema, instance_scenario_action_schema, instance_scenario_create_schema_v01, \
tenant_schema, tenant_edit_schema,\
datacenter_schema, datacenter_edit_schema, datacenter_action_schema, datacenter_associate_schema,\
- object_schema, netmap_new_schema, netmap_edit_schema
+ object_schema, netmap_new_schema, netmap_edit_schema, sdn_controller_schema, sdn_controller_edit_schema, \
+ sdn_port_mapping_schema
+
import nfvo
import utils
from db_base import db_base_Exception
except db_base_Exception as e:
logger.error("http_get_tenants error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/tenants/<tenant_id>', method='GET')
def http_get_tenant_id(tenant_id):
except db_base_Exception as e:
logger.error("http_get_tenant_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/tenants', method='POST')
def http_post_tenants():
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_post_tenants error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/tenants/<tenant_id>', method='PUT')
def http_edit_tenant_id(tenant_id):
except db_base_Exception as e:
logger.error("http_edit_tenant_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/tenants/<tenant_id>', method='DELETE')
def http_delete_tenant_id(tenant_id):
except db_base_Exception as e:
logger.error("http_delete_tenant_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
-
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/datacenters', method='GET')
def http_get_datacenters(tenant_id):
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_get_datacenters error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>', method='GET')
def http_get_datacenter_id(tenant_id, datacenter_id):
what = 'uuid' if utils.check_valid_uuid(datacenter_id) else 'name'
where_={}
where_[what] = datacenter_id
- select_=['uuid', 'name','vim_url', 'vim_url_admin', 'type', 'config', 'description', 'd.created_at as created_at']
+ select_=['uuid', 'name','vim_url', 'vim_url_admin', 'type', 'd.config as config', 'description', 'd.created_at as created_at']
if tenant_id != 'any':
select_.append("datacenter_tenant_id")
where_['td.nfvo_tenant_id']= tenant_id
if tenant_id != 'any':
#get vim tenant info
vim_tenants = mydb.get_rows(
- SELECT=("vim_tenant_name", "vim_tenant_id", "user"),
+ SELECT=("vim_tenant_name", "vim_tenant_id", "user", "passwd", "config"),
FROM="datacenter_tenants",
WHERE={"uuid": datacenters[0]["datacenter_tenant_id"]},
ORDER_BY=("created", ) )
del datacenter["datacenter_tenant_id"]
datacenter["vim_tenants"] = vim_tenants
-
+ for vim_tenant in vim_tenants:
+ if vim_tenant["passwd"]:
+ vim_tenant["passwd"] = "******"
+ if vim_tenant['config'] != None:
+ try:
+ config_dict = yaml.load(vim_tenant['config'])
+ vim_tenant['config'] = config_dict
+ except Exception as e:
+ logger.error("Exception '%s' while trying to load config information", str(e))
+
if datacenter['config'] != None:
try:
config_dict = yaml.load(datacenter['config'])
datacenter['config'] = config_dict
- except Exception, e:
+ except Exception as e:
logger.error("Exception '%s' while trying to load config information", str(e))
#change_keys_http2db(content, http2db_datacenter, reverse=True)
convert_datetime2str(datacenter)
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_get_datacenter_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/datacenters', method='POST')
def http_post_datacenters():
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_post_datacenters error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/datacenters/<datacenter_id_name>', method='PUT')
def http_edit_datacenter_id(datacenter_id_name):
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_edit_datacenter_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
+@bottle.route(url_base + '/<tenant_id>/sdn_controllers', method='POST')
+def http_post_sdn_controller(tenant_id):
+ '''insert a sdn controller into the catalogue. '''
+ #parse input data
+ logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
+ http_content,_ = format_in( sdn_controller_schema )
+ try:
+ logger.debug("tenant_id: "+tenant_id)
+ #logger.debug("content: {}".format(http_content['sdn_controller']))
+
+ data = nfvo.sdn_controller_create(mydb, tenant_id, http_content['sdn_controller'])
+ return format_out({"sdn_controller": nfvo.sdn_controller_list(mydb, tenant_id, data)})
+ except (nfvo.NfvoException, db_base_Exception) as e:
+ logger.error("http_post_sdn_controller error {}: {}".format(e.http_code, str(e)))
+ bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
+@bottle.route(url_base + '/<tenant_id>/sdn_controllers/<controller_id>', method='PUT')
+def http_put_sdn_controller_update(tenant_id, controller_id):
+ '''Update sdn controller'''
+ #parse input data
+ logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
+ http_content,_ = format_in( sdn_controller_edit_schema )
+# r = utils.remove_extra_items(http_content, datacenter_schema)
+# if r:
+# logger.debug("Remove received extra items %s", str(r))
+ try:
+ #logger.debug("tenant_id: "+tenant_id)
+ logger.debug("content: {}".format(http_content['sdn_controller']))
+
+ data = nfvo.sdn_controller_update(mydb, tenant_id, controller_id, http_content['sdn_controller'])
+ return format_out({"sdn_controller": nfvo.sdn_controller_list(mydb, tenant_id, controller_id)})
+
+ except (nfvo.NfvoException, db_base_Exception) as e:
+ logger.error("http_post_sdn_controller error {}: {}".format(e.http_code, str(e)))
+ bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
+@bottle.route(url_base + '/<tenant_id>/sdn_controllers', method='GET')
+def http_get_sdn_controller(tenant_id):
+ '''get sdn controllers list, can use both uuid or name'''
+ try:
+ logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
+
+ data = {'sdn_controllers': nfvo.sdn_controller_list(mydb, tenant_id)}
+ return format_out(data)
+ except (nfvo.NfvoException, db_base_Exception) as e:
+ logger.error("http_get_sdn_controller error {}: {}".format(e.http_code, str(e)))
+ bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
+@bottle.route(url_base + '/<tenant_id>/sdn_controllers/<controller_id>', method='GET')
+def http_get_sdn_controller_id(tenant_id, controller_id):
+ '''get sdn controller details, can use both uuid or name'''
+ try:
+ logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
+ data = nfvo.sdn_controller_list(mydb, tenant_id, controller_id)
+ return format_out({"sdn_controllers": data})
+ except (nfvo.NfvoException, db_base_Exception) as e:
+ logger.error("http_get_sdn_controller_id error {}: {}".format(e.http_code, str(e)))
+ bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
+@bottle.route(url_base + '/<tenant_id>/sdn_controllers/<controller_id>', method='DELETE')
+def http_delete_sdn_controller_id(tenant_id, controller_id):
+ '''delete sdn controller, can use both uuid or name'''
+ try:
+ logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
+ data = nfvo.sdn_controller_delete(mydb, tenant_id, controller_id)
+ return format_out(data)
+ except (nfvo.NfvoException, db_base_Exception) as e:
+ logger.error("http_delete_sdn_controller_id error {}: {}".format(e.http_code, str(e)))
+ bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
+@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>/sdn_mapping', method='POST')
+def http_post_datacenter_sdn_port_mapping(tenant_id, datacenter_id):
+ '''Set the sdn port mapping for a datacenter. '''
+ #parse input data
+ logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
+ http_content, _ = format_in(sdn_port_mapping_schema)
+# r = utils.remove_extra_items(http_content, datacenter_schema)
+# if r:
+# logger.debug("Remove received extra items %s", str(r))
+ try:
+ data = nfvo.datacenter_sdn_port_mapping_set(mydb, tenant_id, datacenter_id, http_content['sdn_port_mapping'])
+ return format_out({"sdn_port_mapping": data})
+ except (nfvo.NfvoException, db_base_Exception) as e:
+ logger.error("http_post_datacenter_sdn_port_mapping error {}: {}".format(e.http_code, str(e)))
+ bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
+@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>/sdn_mapping', method='GET')
+def http_get_datacenter_sdn_port_mapping(tenant_id, datacenter_id):
+ '''get datacenter sdn mapping details, can use both uuid or name'''
+ try:
+ logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
+
+ data = nfvo.datacenter_sdn_port_mapping_list(mydb, tenant_id, datacenter_id)
+ return format_out({"sdn_port_mapping": data})
+ except (nfvo.NfvoException, db_base_Exception) as e:
+ logger.error("http_get_datacenter_sdn_port_mapping error {}: {}".format(e.http_code, str(e)))
+ bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
+@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>/sdn_mapping', method='DELETE')
+def http_delete_datacenter_sdn_port_mapping(tenant_id, datacenter_id):
+ '''clean datacenter sdn mapping, can use both uuid or name'''
+ try:
+ logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
+ data = nfvo.datacenter_sdn_port_mapping_delete(mydb, tenant_id, datacenter_id)
+ return format_out({"result": data})
+ except (nfvo.NfvoException, db_base_Exception) as e:
+ logger.error("http_delete_datacenter_sdn_port_mapping error {}: {}".format(e.http_code, str(e)))
+ bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>/networks', method='GET') #deprecated
@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>/netmaps', method='GET')
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_getnetwork_datacenter_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>/netmaps', method='DELETE')
@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>/netmaps/<netmap_id>', method='DELETE')
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_delnetmap_datacenter_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>/netmaps/upload', method='POST')
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_uploadnetmap_datacenter_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>/netmaps', method='POST')
def http_postnetmap_datacenter_id(tenant_id, datacenter_id):
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_postnetmap_datacenter_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>/netmaps/<netmap_id>', method='PUT')
def http_putnettmap_datacenter_id(tenant_id, datacenter_id, netmap_id):
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_putnettmap_datacenter_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>/action', method='POST')
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_action_datacenter_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
@bottle.route(url_base + '/datacenters/<datacenter_id>', method='DELETE')
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_delete_datacenter_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>', method='POST')
def http_associate_datacenters(tenant_id, datacenter_id):
http_content['datacenter'].get('vim_tenant'),
http_content['datacenter'].get('vim_tenant_name'),
http_content['datacenter'].get('vim_username'),
- http_content['datacenter'].get('vim_password')
- )
+ http_content['datacenter'].get('vim_password'),
+ http_content['datacenter'].get('config')
+ )
return http_get_datacenter_id(tenant_id, id_)
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_associate_datacenters error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
+@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>', method='PUT')
+def http_associate_datacenters_edit(tenant_id, datacenter_id):
+ '''associate an existing datacenter to a this tenant. '''
+ logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
+ #parse input data
+ http_content,_ = format_in( datacenter_associate_schema )
+ r = utils.remove_extra_items(http_content, datacenter_associate_schema)
+ if r:
+ logger.debug("Remove received extra items %s", str(r))
+ try:
+ id_ = nfvo.edit_datacenter_to_tenant(mydb, tenant_id, datacenter_id,
+ http_content['datacenter'].get('vim_tenant'),
+ http_content['datacenter'].get('vim_tenant_name'),
+ http_content['datacenter'].get('vim_username'),
+ http_content['datacenter'].get('vim_password'),
+ http_content['datacenter'].get('config')
+ )
+ return http_get_datacenter_id(tenant_id, id_)
+ except (nfvo.NfvoException, db_base_Exception) as e:
+ logger.error("http_associate_datacenters_edit error {}: {}".format(e.http_code, str(e)))
+ bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
@bottle.route(url_base + '/<tenant_id>/datacenters/<datacenter_id>', method='DELETE')
def http_deassociate_datacenters(tenant_id, datacenter_id):
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_deassociate_datacenters error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/vim/<datacenter_id>/<item>', method='GET')
@bottle.route(url_base + '/<tenant_id>/vim/<datacenter_id>/<item>/<name>', method='GET')
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_get_vim_items error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/vim/<datacenter_id>/<item>/<name>', method='DELETE')
def http_del_vim_items(tenant_id, datacenter_id, item, name):
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_del_vim_items error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
+
@bottle.route(url_base + '/<tenant_id>/vim/<datacenter_id>/<item>', method='POST')
def http_post_vim_items(tenant_id, datacenter_id, item):
logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_post_vim_items error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/vnfs', method='GET')
def http_get_vnfs(tenant_id):
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_get_vnfs error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/vnfs/<vnf_id>', method='GET')
def http_get_vnf_id(tenant_id,vnf_id):
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_get_vnf_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/vnfs', method='POST')
def http_post_vnfs(tenant_id):
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_post_vnfs error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/vnfs/<vnf_id>', method='DELETE')
def http_delete_vnf_id(tenant_id,vnf_id):
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_delete_vnf_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
#@bottle.route(url_base + '/<tenant_id>/hosts/topology', method='GET')
#@bottle.route(url_base + '/<tenant_id>/physicalview/Madrid-Alcantara', method='GET')
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_get_hosts error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
@bottle.route(url_base + '/<path:path>', method='OPTIONS')
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_post_deploy error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/topology/verify', method='POST')
def http_post_verify(tenant_id):
if used_schema == nsd_schema_v01:
scenario_id = nfvo.new_scenario(mydb, tenant_id, http_content)
elif used_schema == nsd_schema_v02:
- scenario_id = nfvo.new_scenario_v02(mydb, tenant_id, http_content)
+ scenario_id = nfvo.new_scenario_v02(mydb, tenant_id, http_content, "0.2")
elif used_schema == nsd_schema_v03:
- scenario_id = nfvo.new_scenario_v03(mydb, tenant_id, http_content)
+ scenario_id = nfvo.new_scenario_v02(mydb, tenant_id, http_content, "0.3")
else:
logger.warning('Unexpected schema_version: %s', http_content.get("schema_version"))
bottle.abort(HTTP_Bad_Request, "Invalid schema version")
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_post_scenarios error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/scenarios/<scenario_id>/action', method='POST')
def http_post_scenario_action(tenant_id, scenario_id):
'''take an action over a scenario'''
logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
- #check valid tenant_id
+ # parse input data
+ http_content, _ = format_in(scenario_action_schema)
+ r = utils.remove_extra_items(http_content, scenario_action_schema)
+ if r:
+ logger.debug("Remove received extra items %s", str(r))
try:
- nfvo.check_tenant(mydb, tenant_id)
- #parse input data
- http_content,_ = format_in( scenario_action_schema )
- r = utils.remove_extra_items(http_content, scenario_action_schema)
- if r:
- logger.debug("Remove received extra items %s", str(r))
+ # check valid tenant_id
+ nfvo.check_tenant(mydb, tenant_id)
if "start" in http_content:
data = nfvo.start_scenario(mydb, tenant_id, scenario_id, http_content['start']['instance_name'], \
http_content['start'].get('description',http_content['start']['instance_name']),
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_post_scenario_action error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/scenarios', method='GET')
def http_get_scenarios(tenant_id):
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_get_scenarios error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/scenarios/<scenario_id>', method='GET')
def http_get_scenario_id(tenant_id, scenario_id):
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_get_scenarios error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/scenarios/<scenario_id>', method='DELETE')
def http_delete_scenario_id(tenant_id, scenario_id):
'''delete a scenario from database, can use both uuid or name'''
+ logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
try:
#check valid tenant_id
if tenant_id != "any":
- nfvo.check_tenant(mydb, tenant_id)
+ nfvo.check_tenant(mydb, tenant_id)
#obtain data
data = mydb.delete_scenario(scenario_id, tenant_id)
#print json.dumps(data, indent=4)
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_delete_scenario_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
@bottle.route(url_base + '/<tenant_id>/scenarios/<scenario_id>', method='PUT')
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_put_scenario_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
@bottle.route(url_base + '/<tenant_id>/instances', method='POST')
def http_post_instances(tenant_id):
- '''take an action over a scenario'''
+ '''create an instance-scenario'''
logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
+ # parse input data
+ http_content, used_schema = format_in(instance_scenario_create_schema_v01)
+ r = utils.remove_extra_items(http_content, used_schema)
+ if r is not None:
+ logger.warning("http_post_instances: Warning: remove extra items %s", str(r))
try:
#check valid tenant_id
if tenant_id != "any":
nfvo.check_tenant(mydb, tenant_id)
- #parse input data
- http_content,used_schema = format_in( instance_scenario_create_schema_v01)
- r = utils.remove_extra_items(http_content, used_schema)
- if r is not None:
- logger.warning("http_post_instances: Warning: remove extra items %s", str(r))
data = nfvo.create_instance(mydb, tenant_id, http_content["instance"])
return format_out(data)
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_post_instances error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
#
# INSTANCES
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_get_instances error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/instances/<instance_id>', method='GET')
def http_get_instance_id(tenant_id, instance_id):
logger.error("http_get_instance_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
except Exception as e:
- logger.error("http_get_instance_id error {}".format(str(e)))
- bottle.abort(HTTP_Internal_Server_Error, str(e))
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/instances/<instance_id>', method='DELETE')
def http_delete_instance_id(tenant_id, instance_id):
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_delete_instance_id error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
+
@bottle.route(url_base + '/<tenant_id>/instances/<instance_id>/action', method='POST')
def http_post_instance_scenario_action(tenant_id, instance_id):
'''take an action over a scenario instance'''
logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url)
+ # parse input data
+ http_content, _ = format_in(instance_scenario_action_schema)
+ r = utils.remove_extra_items(http_content, instance_scenario_action_schema)
+ if r:
+ logger.debug("Remove received extra items %s", str(r))
try:
#check valid tenant_id
if tenant_id != "any":
nfvo.check_tenant(mydb, tenant_id)
- #parse input data
- http_content,_ = format_in( instance_scenario_action_schema )
- r = utils.remove_extra_items(http_content, instance_scenario_action_schema)
- if r:
- logger.debug("Remove received extra items %s", str(r))
#print "http_post_instance_scenario_action input: ", http_content
#obtain data
instance = mydb.get_instance_scenario(instance_id, tenant_id)
except (nfvo.NfvoException, db_base_Exception) as e:
logger.error("http_post_instance_scenario_action error {}: {}".format(e.http_code, str(e)))
bottle.abort(e.http_code, str(e))
+ except Exception as e:
+ logger.error("Unexpected exception: ", exc_info=True)
+ bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e))
@bottle.error(400)
projects / osm / RO.git / blobdiff