X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=osm_ro%2Fhttpserver.py;h=374676e64e3ed5233eea95cbe6d3f01cd568d260;hb=20a608ce0d4a849f30d7125cf1dd63e81dc8cccc;hp=f9cbb9b47bb5365cd9cf5cbd93452bc00cccf500;hpb=17ab9d223b90f867b41e9423f21915fbe336f9db;p=osm%2FRO.git diff --git a/osm_ro/httpserver.py b/osm_ro/httpserver.py index f9cbb9b4..374676e6 100644 --- a/osm_ro/httpserver.py +++ b/osm_ro/httpserver.py @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- ## -# Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U. +# Copyright 2015 Telefonica Investigacion y Desarrollo, S.A.U. # This file is part of openmano # All Rights Reserved. # @@ -183,17 +183,18 @@ def format_out(data): #return data #json no style return json.dumps(data, indent=4) + "\n" -def format_in(default_schema, version_fields=None, version_dict_schema=None): - ''' Parse the content of HTTP request against a json_schema - Parameters - default_schema: The schema to be parsed by default if no version field is found in the client data - version_fields: If provided it contains a tuple or list with the fields to iterate across the client data to obtain the version - version_dict_schema: It contains a dictionary with the version as key, and json schema to apply as value - It can contain a None as key, and this is apply if the client data version does not match any key - Return: - user_data, used_schema: if the data is successfully decoded and matches the schema - launch a bottle abort if fails - ''' +def format_in(default_schema, version_fields=None, version_dict_schema=None, confidential_data=False): + """ + Parse the content of HTTP request against a json_schema + :param default_schema: The schema to be parsed by default if no version field is found in the client data. In None + no validation is done + :param version_fields: If provided it contains a tuple or list with the fields to iterate across the client data to + obtain the version + :param version_dict_schema: It contains a dictionary with the version as key, and json schema to apply as value. + It can contain a None as key, and this is apply if the client data version does not match any key + :return: user_data, used_schema: if the data is successfully decoded and matches the schema. + Launch a bottle abort if fails + """ #print "HEADERS :" + str(bottle.request.headers.items()) try: error_text = "Invalid header format " @@ -212,13 +213,19 @@ def format_in(default_schema, version_fields=None, version_dict_schema=None): logger.warning('Content-Type ' + str(format_type) + ' not supported.') bottle.abort(HTTP_Not_Acceptable, 'Content-Type ' + str(format_type) + ' not supported.') return - #if client_data == None: + # if client_data == None: # bottle.abort(HTTP_Bad_Request, "Content error, empty") # return - - logger.debug('IN: %s', yaml.safe_dump(client_data, explicit_start=True, indent=4, default_flow_style=False, tags=False, encoding='utf-8', allow_unicode=True) ) - #look for the client provider version + if confidential_data: + logger.debug('IN: %s', remove_clear_passwd (yaml.safe_dump(client_data, explicit_start=True, indent=4, default_flow_style=False, + tags=False, encoding='utf-8', allow_unicode=True))) + else: + logger.debug('IN: %s', yaml.safe_dump(client_data, explicit_start=True, indent=4, default_flow_style=False, + tags=False, encoding='utf-8', allow_unicode=True) ) + # look for the client provider version error_text = "Invalid content " + if not default_schema and not version_fields: + return client_data, None client_version = None used_schema = None if version_fields != None: @@ -229,9 +236,9 @@ def format_in(default_schema, version_fields=None, version_dict_schema=None): else: client_version=None break - if client_version==None: - used_schema=default_schema - elif version_dict_schema!=None: + if client_version == None: + used_schema = default_schema + elif version_dict_schema != None: if client_version in version_dict_schema: used_schema = version_dict_schema[client_version] elif None in version_dict_schema: @@ -241,7 +248,7 @@ def format_in(default_schema, version_fields=None, version_dict_schema=None): js_v(client_data, used_schema) return client_data, used_schema - except (ValueError, yaml.YAMLError) as exc: + except (TypeError, ValueError, yaml.YAMLError) as exc: error_text += str(exc) logger.error(error_text) bottle.abort(HTTP_Bad_Request, error_text) @@ -323,6 +330,8 @@ def http_get_tenants(): convert_datetime2str(tenants) data={'tenants' : tenants} return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -337,11 +346,22 @@ def http_get_tenant_id(tenant_id): #obtain data logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url) try: - tenant = mydb.get_table_by_uuid_name('nfvo_tenants', tenant_id, "tenant") + from_ = 'nfvo_tenants' + select_, where_, limit_ = filter_query_string(bottle.request.query, None, + ('uuid', 'name', 'description', 'created_at')) + what = 'uuid' if utils.check_valid_uuid(tenant_id) else 'name' + where_[what] = tenant_id + tenants = mydb.get_rows(FROM=from_, SELECT=select_,WHERE=where_) #change_keys_http2db(content, http2db_tenant, reverse=True) - convert_datetime2str(tenant) - data={'tenant' : tenant} + if len(tenants) == 0: + bottle.abort(HTTP_Not_Found, "No tenant found with {}='{}'".format(what, tenant_id)) + elif len(tenants) > 1: + bottle.abort(HTTP_Bad_Request, "More than one tenant found with {}='{}'".format(what, tenant_id)) + convert_datetime2str(tenants[0]) + data = {'tenant': tenants[0]} return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -362,6 +382,8 @@ def http_post_tenants(): try: data = nfvo.new_tenant(mydb, http_content['tenant']) return http_get_tenant_id(data) + except bottle.HTTPError: + raise 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)) @@ -388,6 +410,8 @@ def http_edit_tenant_id(tenant_id): where={'uuid': tenant['uuid']} mydb.update_rows('nfvo_tenants', http_content['tenant'], where) return http_get_tenant_id(tenant_id) + except bottle.HTTPError: + raise 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)) @@ -403,6 +427,8 @@ def http_delete_tenant_id(tenant_id): try: data = nfvo.delete_tenant(mydb, tenant_id) return format_out({"result":"tenant " + data + " deleted"}) + except bottle.HTTPError: + raise 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)) @@ -435,6 +461,8 @@ def http_get_datacenters(tenant_id): convert_datetime2str(datacenters) data={'datacenters' : datacenters} return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -443,6 +471,54 @@ def http_get_datacenters(tenant_id): bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e)) +@bottle.route(url_base + '//vim_accounts', method='GET') +@bottle.route(url_base + '//vim_accounts/', method='GET') +def http_get_vim_account(tenant_id, vim_account_id=None): + '''get vim_account list/details, ''' + logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url) + try: + select_ = ('uuid', 'name', 'dt.datacenter_id as vim_id', 'vim_tenant_name', 'vim_tenant_id', 'user', 'config', + 'dt.created_at as created_at', 'passwd') + where_ = {'nfvo_tenant_id': tenant_id} + if vim_account_id: + where_['dt.uuid'] = vim_account_id + from_ = 'tenants_datacenters as td join datacenter_tenants as dt on dt.uuid=td.datacenter_tenant_id' + vim_accounts = mydb.get_rows(SELECT=select_, FROM=from_, WHERE=where_) + + if len(vim_accounts) == 0 and vim_account_id: + bottle.abort(HTTP_Not_Found, "No vim_account found for tenant {} and id '{}'".format(tenant_id, + vim_account_id)) + for vim_account in vim_accounts: + if vim_account["passwd"]: + vim_account["passwd"] = "******" + if vim_account['config'] != None: + try: + config_dict = yaml.load(vim_account['config']) + vim_account['config'] = config_dict + if vim_account['config'].get('admin_password'): + vim_account['config']['admin_password'] = "******" + if vim_account['config'].get('vcenter_password'): + vim_account['config']['vcenter_password'] = "******" + if vim_account['config'].get('nsx_password'): + vim_account['config']['nsx_password'] = "******" + 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(vim_account) + if vim_account_id: + return format_out({"datacenter": vim_accounts[0]}) + else: + return format_out({"datacenters": vim_accounts}) + except bottle.HTTPError: + raise + 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='GET') def http_get_datacenter_id(tenant_id, datacenter_id): '''get datacenter details, can use both uuid or name''' @@ -488,6 +564,12 @@ def http_get_datacenter_id(tenant_id, datacenter_id): try: config_dict = yaml.load(vim_tenant['config']) vim_tenant['config'] = config_dict + if vim_tenant['config'].get('admin_password'): + vim_tenant['config']['admin_password'] = "******" + if vim_tenant['config'].get('vcenter_password'): + vim_tenant['config']['vcenter_password'] = "******" + if vim_tenant['config'].get('nsx_password'): + vim_tenant['config']['nsx_password'] = "******" except Exception as e: logger.error("Exception '%s' while trying to load config information", str(e)) @@ -495,12 +577,20 @@ def http_get_datacenter_id(tenant_id, datacenter_id): try: config_dict = yaml.load(datacenter['config']) datacenter['config'] = config_dict + if datacenter['config'].get('admin_password'): + datacenter['config']['admin_password'] = "******" + if datacenter['config'].get('vcenter_password'): + datacenter['config']['vcenter_password'] = "******" + if datacenter['config'].get('nsx_password'): + datacenter['config']['nsx_password'] = "******" 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) data={'datacenter' : datacenter} return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -514,13 +604,15 @@ def http_post_datacenters(): '''insert a datacenter 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( datacenter_schema ) + http_content,_ = format_in(datacenter_schema, confidential_data=True) r = utils.remove_extra_items(http_content, datacenter_schema) if r: logger.debug("Remove received extra items %s", str(r)) try: data = nfvo.new_datacenter(mydb, http_content['datacenter']) return http_get_datacenter_id('any', data) + except bottle.HTTPError: + raise 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)) @@ -542,6 +634,8 @@ def http_edit_datacenter_id(datacenter_id_name): try: datacenter_id = nfvo.edit_datacenter(mydb, datacenter_id_name, http_content['datacenter']) return http_get_datacenter_id('any', datacenter_id) + except bottle.HTTPError: + raise 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)) @@ -561,6 +655,8 @@ def http_post_sdn_controller(tenant_id): 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 bottle.HTTPError: + raise 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)) @@ -584,6 +680,8 @@ def http_put_sdn_controller_update(tenant_id, controller_id): 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 bottle.HTTPError: + raise 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)) @@ -599,6 +697,8 @@ def http_get_sdn_controller(tenant_id): data = {'sdn_controllers': nfvo.sdn_controller_list(mydb, tenant_id)} return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -613,6 +713,8 @@ def http_get_sdn_controller_id(tenant_id, controller_id): 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 bottle.HTTPError: + raise 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)) @@ -627,6 +729,8 @@ def http_delete_sdn_controller_id(tenant_id, controller_id): 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 bottle.HTTPError: + raise 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)) @@ -646,6 +750,8 @@ def http_post_datacenter_sdn_port_mapping(tenant_id, datacenter_id): 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 bottle.HTTPError: + raise 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)) @@ -661,6 +767,8 @@ def http_get_datacenter_sdn_port_mapping(tenant_id, datacenter_id): data = nfvo.datacenter_sdn_port_mapping_list(mydb, tenant_id, datacenter_id) return format_out({"sdn_port_mapping": data}) + except bottle.HTTPError: + raise 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)) @@ -675,6 +783,8 @@ def http_delete_datacenter_sdn_port_mapping(tenant_id, datacenter_id): 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 bottle.HTTPError: + raise 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)) @@ -710,6 +820,8 @@ def http_getnetmap_datacenter_id(tenant_id, datacenter_id, netmap_id=None): else: data={'netmaps' : netmaps} return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -734,12 +846,14 @@ def http_delnetmap_datacenter_id(tenant_id, datacenter_id, netmap_id=None): where_["name"] = netmap_id #change_keys_http2db(content, http2db_tenant, reverse=True) deleted = mydb.delete_row(FROM='datacenter_nets', WHERE= where_) - if deleted == 0 and netmap_id : + if deleted == 0 and netmap_id: bottle.abort(HTTP_Not_Found, "No netmap found with " + " and ".join(map(lambda x: str(x[0])+": "+str(x[1]), where_.iteritems())) ) if netmap_id: return format_out({"result": "netmap %s deleted" % netmap_id}) else: return format_out({"result": "%d netmap deleted" % deleted}) + except bottle.HTTPError: + raise 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)) @@ -757,6 +871,8 @@ def http_uploadnetmap_datacenter_id(tenant_id, datacenter_id): utils.convert_str2boolean(netmaps, ('shared', 'multipoint') ) data={'netmaps' : netmaps} return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -781,6 +897,8 @@ def http_postnetmap_datacenter_id(tenant_id, datacenter_id): utils.convert_str2boolean(netmaps, ('shared', 'multipoint') ) data={'netmaps' : netmaps} return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -803,6 +921,8 @@ def http_putnettmap_datacenter_id(tenant_id, datacenter_id, netmap_id): try: nfvo.datacenter_edit_netmap(mydb, tenant_id, datacenter_id, netmap_id, http_content) return http_getnetmap_datacenter_id(tenant_id, datacenter_id, netmap_id) + except bottle.HTTPError: + raise 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)) @@ -827,6 +947,8 @@ def http_action_datacenter_id(tenant_id, datacenter_id): return http_getnetmap_datacenter_id(datacenter_id) else: return format_out(result) + except bottle.HTTPError: + raise 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)) @@ -843,6 +965,8 @@ def http_delete_datacenter_id( datacenter_id): try: data = nfvo.delete_datacenter(mydb, datacenter_id) return format_out({"result":"datacenter '" + data + "' deleted"}) + except bottle.HTTPError: + raise 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)) @@ -852,23 +976,21 @@ def http_delete_datacenter_id( datacenter_id): @bottle.route(url_base + '//datacenters/', method='POST') -def http_associate_datacenters(tenant_id, datacenter_id): +@bottle.route(url_base + '//vim_accounts', method='POST') +def http_associate_datacenters(tenant_id, datacenter_id=None): '''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 ) + http_content,_ = format_in(datacenter_associate_schema, confidential_data=True) r = utils.remove_extra_items(http_content, datacenter_associate_schema) if r: logger.debug("Remove received extra items %s", str(r)) try: - id_ = nfvo.associate_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_) + vim_account_id = nfvo.create_vim_account(mydb, tenant_id, datacenter_id, + **http_content['datacenter']) + return http_get_vim_account(tenant_id, vim_account_id) + except bottle.HTTPError: + raise 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)) @@ -876,38 +998,40 @@ def http_associate_datacenters(tenant_id, datacenter_id): logger.error("Unexpected exception: ", exc_info=True) bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e)) +@bottle.route(url_base + '//vim_accounts/', method='PUT') @bottle.route(url_base + '//datacenters/', method='PUT') -def http_associate_datacenters_edit(tenant_id, datacenter_id): +def http_vim_account_edit(tenant_id, vim_account_id=None, datacenter_id=None): '''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 ) + 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_) + vim_account_id = nfvo.edit_vim_account(mydb, tenant_id, vim_account_id, datacenter_id=datacenter_id, + **http_content['datacenter']) + return http_get_vim_account(tenant_id, vim_account_id) + except bottle.HTTPError: + raise except (nfvo.NfvoException, db_base_Exception) as e: - logger.error("http_associate_datacenters_edit error {}: {}".format(e.http_code, str(e))) + logger.error("http_vim_account_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 + '//datacenters/', method='DELETE') -def http_deassociate_datacenters(tenant_id, datacenter_id): +@bottle.route(url_base + '//vim_accounts/', method='DELETE') +def http_deassociate_datacenters(tenant_id, datacenter_id=None, vim_account_id=None): '''deassociate an existing datacenter to a this tenant. ''' logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url) try: - data = nfvo.deassociate_datacenter_to_tenant(mydb, tenant_id, datacenter_id) + data = nfvo.delete_vim_account(mydb, tenant_id, vim_account_id, datacenter_id) return format_out({"result": data}) + except bottle.HTTPError: + raise 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)) @@ -922,6 +1046,8 @@ def http_post_vim_net_sdn_attach(tenant_id, datacenter_id, network_id): try: data = nfvo.vim_net_sdn_attach(mydb, tenant_id, datacenter_id, network_id, http_content) return format_out(data) + except bottle.HTTPError: + raise except (nfvo.NfvoException, db_base_Exception) as e: logger.error("http_post_vim_net_sdn_attach error {}: {}".format(e.http_code, str(e))) bottle.abort(e.http_code, str(e)) @@ -936,6 +1062,8 @@ def http_delete_vim_net_sdn_detach(tenant_id, datacenter_id, network_id, port_id try: data = nfvo.vim_net_sdn_detach(mydb, tenant_id, datacenter_id, network_id, port_id) return format_out(data) + except bottle.HTTPError: + raise except (nfvo.NfvoException, db_base_Exception) as e: logger.error("http_delete_vim_net_sdn_detach error {}: {}".format(e.http_code, str(e))) bottle.abort(e.http_code, str(e)) @@ -950,6 +1078,8 @@ def http_get_vim_items(tenant_id, datacenter_id, item, name=None): try: data = nfvo.vim_action_get(mydb, tenant_id, datacenter_id, item, name) return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -964,6 +1094,8 @@ def http_del_vim_items(tenant_id, datacenter_id, item, name): try: data = nfvo.vim_action_delete(mydb, tenant_id, datacenter_id, item, name) return format_out({"result":data}) + except bottle.HTTPError: + raise 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)) @@ -979,6 +1111,8 @@ def http_post_vim_items(tenant_id, datacenter_id, item): try: data = nfvo.vim_action_create(mydb, tenant_id, datacenter_id, item, http_content) return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -995,17 +1129,17 @@ def http_get_vnfs(tenant_id): #check valid tenant_id nfvo.check_tenant(mydb, tenant_id) select_,where_,limit_ = filter_query_string(bottle.request.query, None, - ('uuid','name','description','public', "tenant_id", "created_at") ) - where_or = {} + ('uuid', 'name', 'osm_id', 'description', 'public', "tenant_id", "created_at") ) if tenant_id != "any": - where_or["tenant_id"] = tenant_id - where_or["public"] = True - vnfs = mydb.get_rows(FROM='vnfs', SELECT=select_,WHERE=where_,WHERE_OR=where_or, WHERE_AND_OR="AND",LIMIT=limit_) - #change_keys_http2db(content, http2db_vnf, reverse=True) + where_["OR"]={"tenant_id": tenant_id, "public": True} + vnfs = mydb.get_rows(FROM='vnfs', SELECT=select_, WHERE=where_, LIMIT=limit_) + # change_keys_http2db(content, http2db_vnf, reverse=True) utils.convert_str2boolean(vnfs, ('public',)) convert_datetime2str(vnfs) - data={'vnfs' : vnfs} + data={'vnfs': vnfs} return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -1023,6 +1157,8 @@ def http_get_vnf_id(tenant_id,vnf_id): utils.convert_str2boolean(vnf, ('public',)) convert_datetime2str(vnf) return format_out(vnf) + except bottle.HTTPError: + raise 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)) @@ -1033,9 +1169,12 @@ def http_get_vnf_id(tenant_id,vnf_id): @bottle.route(url_base + '//vnfs', method='POST') def http_post_vnfs(tenant_id): - '''insert a vnf into the catalogue. Creates the flavor and images in the VIM, and creates the VNF and its internal structure in the OPENMANO DB''' - #print "Parsing the YAML file of the VNF" - #parse input data + """ Insert a vnf into the catalogue. Creates the flavor and images, and fill the tables at database + :param tenant_id: tenant that this vnf belongs to + :return: + """ + # print "Parsing the YAML file of the VNF" + # parse input data logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url) http_content, used_schema = format_in( vnfd_schema_v01, ("schema_version",), {"0.2": vnfd_schema_v02}) r = utils.remove_extra_items(http_content, used_schema) @@ -1050,6 +1189,36 @@ def http_post_vnfs(tenant_id): logger.warning('Unexpected schema_version: %s', http_content.get("schema_version")) bottle.abort(HTTP_Bad_Request, "Invalid schema version") return http_get_vnf_id(tenant_id, vnf_id) + except bottle.HTTPError: + raise + 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 + '/v3//vnfd', method='POST') +def http_post_vnfs_v3(tenant_id): + """ + Insert one or several VNFs in the catalog, following OSM IM + :param tenant_id: tenant owner of the VNF + :return: The detailed list of inserted VNFs, following the old format + """ + logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url) + http_content, _ = format_in(None) + try: + vnfd_uuid_list = nfvo.new_vnfd_v3(mydb, tenant_id, http_content) + vnfd_list = [] + for vnfd_uuid in vnfd_uuid_list: + vnf = nfvo.get_vnf_id(mydb, tenant_id, vnfd_uuid) + utils.convert_str2boolean(vnf, ('public',)) + convert_datetime2str(vnf) + vnfd_list.append(vnf["vnf"]) + return format_out({"vnfd": vnfd_list}) + except bottle.HTTPError: + raise 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)) @@ -1057,9 +1226,8 @@ def http_post_vnfs(tenant_id): logger.error("Unexpected exception: ", exc_info=True) bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e)) - @bottle.route(url_base + '//vnfs/', method='DELETE') -def http_delete_vnf_id(tenant_id,vnf_id): +def http_delete_vnf_id(tenant_id, vnf_id): '''delete a vnf from database, and images and flavors in VIM when appropriate, can use both uuid or name''' logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url) #check valid tenant_id and deletes the vnf, including images, @@ -1067,6 +1235,8 @@ def http_delete_vnf_id(tenant_id,vnf_id): data = nfvo.delete_vnf(mydb,tenant_id,vnf_id) #print json.dumps(data, indent=4) return format_out({"result":"VNF " + data + " deleted"}) + except bottle.HTTPError: + raise 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)) @@ -1096,6 +1266,8 @@ def http_get_hosts(tenant_id, datacenter): convert_datetime2str(data) #print json.dumps(data, indent=4) return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -1131,6 +1303,8 @@ def http_post_deploy(tenant_id): instance = nfvo.start_scenario(mydb, tenant_id, scenario_id, http_content['name'], http_content['name']) #print json.dumps(data, indent=4) return format_out(instance) + except bottle.HTTPError: + raise 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)) @@ -1172,6 +1346,8 @@ def http_post_scenarios(tenant_id): #print json.dumps(data, indent=4) #return format_out(data) return http_get_scenario_id(tenant_id, scenario_id) + except bottle.HTTPError: + raise 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)) @@ -1179,6 +1355,33 @@ def http_post_scenarios(tenant_id): logger.error("Unexpected exception: ", exc_info=True) bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e)) +@bottle.route(url_base + '/v3//nsd', method='POST') +def http_post_nsds_v3(tenant_id): + """ + Insert one or several NSDs in the catalog, following OSM IM + :param tenant_id: tenant owner of the NSD + :return: The detailed list of inserted NSDs, following the old format + """ + logger.debug('FROM %s %s %s', bottle.request.remote_addr, bottle.request.method, bottle.request.url) + http_content, _ = format_in(None) + try: + nsd_uuid_list = nfvo.new_nsd_v3(mydb, tenant_id, http_content) + nsd_list = [] + for nsd_uuid in nsd_uuid_list: + scenario = mydb.get_scenario(nsd_uuid, tenant_id) + convert_datetime2str(scenario) + nsd_list.append(scenario) + data = {'nsd': nsd_list} + return format_out(data) + except bottle.HTTPError: + raise + except (nfvo.NfvoException, db_base_Exception) as e: + logger.error("http_post_nsds_v3 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 + '//scenarios//action', method='POST') def http_post_scenario_action(tenant_id, scenario_id): @@ -1214,6 +1417,8 @@ def http_post_scenario_action(tenant_id, scenario_id): instance_id = data['uuid'] nfvo.delete_instance(mydb, tenant_id,instance_id) return format_out({"result":"Verify OK"}) + except bottle.HTTPError: + raise 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)) @@ -1231,17 +1436,18 @@ def http_get_scenarios(tenant_id): if tenant_id != "any": nfvo.check_tenant(mydb, tenant_id) #obtain data - s,w,l=filter_query_string(bottle.request.query, None, ('uuid', 'name', 'description', 'tenant_id', 'created_at', 'public')) - where_or={} + s,w,l=filter_query_string(bottle.request.query, None, + ('uuid', 'name', 'osm_id', 'description', 'tenant_id', 'created_at', 'public')) if tenant_id != "any": - where_or["tenant_id"] = tenant_id - where_or["public"] = True - scenarios = mydb.get_rows(SELECT=s, WHERE=w, WHERE_OR=where_or, WHERE_AND_OR="AND", LIMIT=l, FROM='scenarios') + w["OR"] = {"tenant_id": tenant_id, "public": True} + scenarios = mydb.get_rows(SELECT=s, WHERE=w, LIMIT=l, FROM='scenarios') convert_datetime2str(scenarios) utils.convert_str2boolean(scenarios, ('public',) ) data={'scenarios':scenarios} #print json.dumps(scenarios, indent=4) return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -1263,6 +1469,8 @@ def http_get_scenario_id(tenant_id, scenario_id): convert_datetime2str(scenario) data={'scenario' : scenario} return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -1283,6 +1491,8 @@ def http_delete_scenario_id(tenant_id, scenario_id): data = mydb.delete_scenario(scenario_id, tenant_id) #print json.dumps(data, indent=4) return format_out({"result":"scenario " + data + " deleted"}) + except bottle.HTTPError: + raise 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)) @@ -1304,6 +1514,8 @@ def http_put_scenario_id(tenant_id, scenario_id): #print json.dumps(data, indent=4) #return format_out(data) return http_get_scenario_id(tenant_id, scenario_id) + except bottle.HTTPError: + raise 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)) @@ -1326,6 +1538,8 @@ def http_post_instances(tenant_id): nfvo.check_tenant(mydb, tenant_id) data = nfvo.create_instance(mydb, tenant_id, http_content["instance"]) return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -1352,6 +1566,8 @@ def http_get_instances(tenant_id): utils.convert_str2boolean(instances, ('public',) ) data={'instances':instances} return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -1365,19 +1581,15 @@ def http_get_instance_id(tenant_id, instance_id): '''get instances details, 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) if tenant_id == "any": tenant_id = None - #obtain data (first time is only to check that the instance exists) - instance_dict = mydb.get_instance_scenario(instance_id, tenant_id, verbose=True) - try: - nfvo.refresh_instance(mydb, tenant_id, instance_dict) - except (nfvo.NfvoException, db_base_Exception) as e: - logger.warn("nfvo.refresh_instance couldn't refresh the status of the instance: %s" % str(e)) - # obtain data with results upated - instance = mydb.get_instance_scenario(instance_id, tenant_id) + + instance = nfvo.get_instance_id(mydb, tenant_id, instance_id) + # Workaround to SO, convert vnfs:vms:interfaces:ip_address from ";" separated list to report the first value for vnf in instance.get("vnfs", ()): for vm in vnf.get("vms", ()): @@ -1389,6 +1601,8 @@ def http_get_instance_id(tenant_id, instance_id): convert_datetime2str(instance) # print json.dumps(instance, indent=4) return format_out(instance) + except bottle.HTTPError: + raise except (nfvo.NfvoException, db_base_Exception) as e: logger.error("http_get_instance_id error {}: {}".format(e.http_code, str(e))) bottle.abort(e.http_code, str(e)) @@ -1410,6 +1624,8 @@ def http_delete_instance_id(tenant_id, instance_id): #obtain data message = nfvo.delete_instance(mydb, tenant_id,instance_id) return format_out({"result":message}) + except bottle.HTTPError: + raise 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)) @@ -1420,7 +1636,12 @@ def http_delete_instance_id(tenant_id, instance_id): @bottle.route(url_base + '//instances//action', method='POST') def http_post_instance_scenario_action(tenant_id, instance_id): - '''take an action over a scenario instance''' + """ + take an action over a scenario instance + :param tenant_id: tenant where user belongs to + :param instance_id: instance indentity + :return: + """ 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) @@ -1439,6 +1660,8 @@ def http_post_instance_scenario_action(tenant_id, instance_id): data = nfvo.instance_action(mydb, tenant_id, instance_id, http_content) return format_out(data) + except bottle.HTTPError: + raise 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)) @@ -1447,6 +1670,49 @@ def http_post_instance_scenario_action(tenant_id, instance_id): bottle.abort(HTTP_Internal_Server_Error, type(e).__name__ + ": " + str(e)) +@bottle.route(url_base + '//instances//action', method='GET') +@bottle.route(url_base + '//instances//action/', method='GET') +def http_get_instance_scenario_action(tenant_id, instance_id, action_id=None): + """ + List the actions done over an instance, or the action details + :param tenant_id: tenant where user belongs to. Can be "any" to ignore + :param instance_id: instance id, can be "any" to get actions of all instances + :return: + """ + 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) + data = nfvo.instance_action_get(mydb, tenant_id, instance_id, action_id) + return format_out(data) + except bottle.HTTPError: + raise + except (nfvo.NfvoException, db_base_Exception) as e: + logger.error("http_get_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)) + +def remove_clear_passwd(data): + """ + Removes clear passwords from the data received + :param data: data with clear password + :return: data without the password information + """ + + passw = ['password: ', 'passwd: '] + + for pattern in passw: + init = data.find(pattern) + while init != -1: + end = data.find('\n', init) + data = data[:init] + '{}******'.format(pattern) + data[end:] + init += 1 + init = data.find(pattern, init) + return data + @bottle.error(400) @bottle.error(401) @bottle.error(404)