| #!/usr/bin/env python3 |
| # -*- coding: utf-8 -*- |
| |
| ## |
| # Copyright 2015 Telefonica Investigacion y Desarrollo, S.A.U. |
| # This file is part of openmano |
| # All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); you may |
| # not use this file except in compliance with the License. You may obtain |
| # a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| # License for the specific language governing permissions and limitations |
| # under the License. |
| # |
| # For those usages not covered by the Apache License, Version 2.0 please |
| # contact with: nfvlabs@tid.es |
| ## |
| |
| """ |
| openmano python client used to interact with openmano-server |
| """ |
| |
| import requests |
| import json |
| import yaml |
| import logging |
| import sys |
| |
| __author__ = "Alfonso Tierno, Pablo Montes" |
| __date__ = "$09-Mar-2016 09:09:48$" |
| __version__ = "0.1.0-r470" |
| version_date = "Oct 2017" |
| |
| if sys.version_info.major == 3: |
| from urllib.parse import quote |
| elif sys.version_info.major == 2: |
| from urllib import quote |
| |
| class OpenmanoException(Exception): |
| '''Common Exception for all openmano client exceptions''' |
| |
| class OpenmanoBadParamsException(OpenmanoException): |
| '''Bad or missing input parameters''' |
| |
| class OpenmanoResponseException(OpenmanoException): |
| '''Unexpected response from openmano server''' |
| |
| class OpenmanoNotFoundException(OpenmanoException): |
| '''Not found at server''' |
| |
| # class vnf(): |
| # def __init__(self, message): |
| # print "Error: %s" %message |
| # print |
| # self.print_usage() |
| # #self.print_help() |
| # print |
| # print "Type 'openmano -h' for help" |
| |
| class openmanoclient(): |
| headers_req = {'Accept': 'application/yaml', 'content-type': 'application/yaml'} |
| |
| def __init__(self, **kwargs): |
| self.username = kwargs.get("username") |
| self.password = kwargs.get("password") |
| self.endpoint_url = kwargs.get("endpoint_url") |
| self.tenant_id = kwargs.get("tenant_id") |
| self.tenant_name = kwargs.get("tenant_name") |
| self.tenant = None |
| self.datacenter_id = kwargs.get("datacenter_id") |
| self.datacenter_name = kwargs.get("datacenter_name") |
| self.datacenter = None |
| self.logger = logging.getLogger(kwargs.get('logger','manoclient')) |
| if kwargs.get("debug"): |
| self.logger.setLevel(logging.DEBUG) |
| |
| def __getitem__(self, index): |
| if index=='tenant_name': |
| return self.tenant_name |
| elif index=='tenant_id': |
| return self.tenant_id |
| elif index=='datacenter_name': |
| return self.datacenter_name |
| elif index=='datacenter_id': |
| return self.datacenter_id |
| elif index=='username': |
| return self.username |
| elif index=='password': |
| return self.password |
| elif index=='endpoint_url': |
| return self.endpoint_url |
| else: |
| raise KeyError("Invalid key '%s'" %str(index)) |
| |
| def __setitem__(self,index, value): |
| if index=='tenant_name': |
| self.tenant_name = value |
| elif index=='tenant_id': |
| self.tenant_id = value |
| elif index=='datacenter_name': |
| self.datacenter_name = value |
| elif index=='datacenter_id': |
| self.datacenter_id = value |
| elif index=='username': |
| self.username = value |
| elif index=='password': |
| self.password = value |
| elif index=='endpoint_url': |
| self.endpoint_url = value |
| else: |
| raise KeyError("Invalid key '%s'" %str(index)) |
| self.tenant = None # force to reload tenant with different credentials |
| self.datacenter = None # force to reload datacenter with different credentials |
| |
| def _parse(self, descriptor, descriptor_format, response=False): |
| #try yaml |
| if descriptor_format and descriptor_format != "json" and descriptor_format != "yaml": |
| raise OpenmanoBadParamsException("'descriptor_format' must be a 'json' or 'yaml' text") |
| if descriptor_format != "json": |
| try: |
| return yaml.load(descriptor) |
| except yaml.YAMLError as exc: |
| error_pos = "" |
| if hasattr(exc, 'problem_mark'): |
| mark = exc.problem_mark |
| error_pos = " at line:{} column:{}s".format(mark.line+1, mark.column+1) |
| error_text = "yaml format error" + error_pos |
| elif descriptor_format != "yaml": |
| try: |
| return json.loads(descriptor) |
| except Exception as e: |
| if response: |
| error_text = "json format error" + str(e) |
| |
| if response: |
| raise OpenmanoResponseException(error_text) |
| raise OpenmanoBadParamsException(error_text) |
| |
| def _parse_yaml(self, descriptor, response=False): |
| try: |
| return yaml.load(descriptor) |
| except yaml.YAMLError as exc: |
| error_pos = "" |
| if hasattr(exc, 'problem_mark'): |
| mark = exc.problem_mark |
| error_pos = " at line:{} column:{}s".format(mark.line+1, mark.column+1) |
| error_text = "yaml format error" + error_pos |
| if response: |
| raise OpenmanoResponseException(error_text) |
| raise OpenmanoBadParamsException(error_text) |
| |
| |
| def _get_item_uuid(self, item, item_id=None, item_name=None, all_tenants=False): |
| if all_tenants == None: |
| tenant_text = "" |
| elif all_tenants == False: |
| tenant_text = "/" + self.tenant |
| else: |
| tenant_text = "/any" |
| URLrequest = "{}{}/{}".format(self.endpoint_url, tenant_text, item) |
| self.logger.debug("GET %s", URLrequest ) |
| mano_response = requests.get(URLrequest, headers=self.headers_req) |
| self.logger.debug("openmano response: %s", mano_response.text ) |
| content = self._parse_yaml(mano_response.text, response=True) |
| #print content |
| found = 0 |
| if not item_id and not item_name: |
| raise OpenmanoResponseException("Missing either {0}_name or {0}_id".format(item[:-1])) |
| for i in content[item]: |
| if item_id and i["uuid"] == item_id: |
| return item_id |
| elif item_name and i["name"] == item_name: |
| uuid = i["uuid"] |
| found += 1 |
| |
| if found == 0: |
| if item_id: |
| raise OpenmanoNotFoundException("No {} found with id '{}'".format(item[:-1], item_id)) |
| else: |
| #print(item, item_name) |
| raise OpenmanoNotFoundException("No {} found with name '{}'".format(item[:-1], item_name) ) |
| elif found > 1: |
| raise OpenmanoNotFoundException("{} {} found with name '{}'. uuid must be used".format(found, item, item_name)) |
| return uuid |
| |
| def _get_item(self, item, uuid=None, name=None, all_tenants=False): |
| if all_tenants: |
| tenant_text = "/any" |
| elif all_tenants==None: |
| tenant_text = "" |
| else: |
| tenant_text = "/"+self._get_tenant() |
| if not uuid: |
| #check that exist |
| uuid = self._get_item_uuid(item, uuid, name, all_tenants) |
| |
| URLrequest = "{}{}/{}/{}".format(self.endpoint_url, tenant_text, item, uuid) |
| self.logger.debug("GET %s", URLrequest ) |
| mano_response = requests.get(URLrequest, headers=self.headers_req) |
| self.logger.debug("openmano response: %s", mano_response.text ) |
| |
| content = self._parse_yaml(mano_response.text, response=True) |
| if mano_response.status_code==200: |
| return content |
| else: |
| raise OpenmanoResponseException(str(content)) |
| |
| def _get_tenant(self): |
| if not self.tenant: |
| self.tenant = self._get_item_uuid("tenants", self.tenant_id, self.tenant_name, None) |
| return self.tenant |
| |
| def _get_datacenter(self): |
| if not self.tenant: |
| self._get_tenant() |
| if not self.datacenter: |
| self.datacenter = self._get_item_uuid("datacenters", self.datacenter_id, self.datacenter_name, False) |
| return self.datacenter |
| |
| def _create_item(self, item, descriptor, all_tenants=False, api_version=None): |
| if all_tenants: |
| tenant_text = "/any" |
| elif all_tenants is None: |
| tenant_text = "" |
| else: |
| tenant_text = "/"+self._get_tenant() |
| payload_req = yaml.safe_dump(descriptor) |
| |
| api_version_text = "" |
| if api_version: |
| api_version_text = "/v3" |
| |
| #print payload_req |
| |
| URLrequest = "{}{apiver}{tenant}/{item}".format(self.endpoint_url, apiver=api_version_text, tenant=tenant_text, |
| item=item) |
| self.logger.debug("openmano POST %s %s", URLrequest, payload_req) |
| mano_response = requests.post(URLrequest, headers=self.headers_req, data=payload_req) |
| self.logger.debug("openmano response: %s", mano_response.text) |
| |
| content = self._parse_yaml(mano_response.text, response=True) |
| if mano_response.status_code == 200: |
| return content |
| else: |
| raise OpenmanoResponseException(str(content)) |
| |
| def _del_item(self, item, uuid=None, name=None, all_tenants=False): |
| if all_tenants: |
| tenant_text = "/any" |
| elif all_tenants==None: |
| tenant_text = "" |
| else: |
| tenant_text = "/"+self._get_tenant() |
| if not uuid: |
| #check that exist |
| uuid = self._get_item_uuid(item, uuid, name, all_tenants) |
| |
| URLrequest = "{}{}/{}/{}".format(self.endpoint_url, tenant_text, item, uuid) |
| self.logger.debug("DELETE %s", URLrequest ) |
| mano_response = requests.delete(URLrequest, headers = self.headers_req) |
| self.logger.debug("openmano response: %s", mano_response.text ) |
| |
| content = self._parse_yaml(mano_response.text, response=True) |
| if mano_response.status_code==200: |
| return content |
| else: |
| raise OpenmanoResponseException(str(content)) |
| |
| def _list_item(self, item, all_tenants=False, filter_dict=None): |
| if all_tenants: |
| tenant_text = "/any" |
| elif all_tenants==None: |
| tenant_text = "" |
| else: |
| tenant_text = "/"+self._get_tenant() |
| |
| URLrequest = "{}{}/{}".format(self.endpoint_url, tenant_text, item) |
| separator="?" |
| if filter_dict: |
| for k in filter_dict: |
| URLrequest += separator + quote(str(k)) + "=" + quote(str(filter_dict[k])) |
| separator = "&" |
| self.logger.debug("openmano GET %s", URLrequest) |
| mano_response = requests.get(URLrequest, headers=self.headers_req) |
| self.logger.debug("openmano response: %s", mano_response.text ) |
| |
| content = self._parse_yaml(mano_response.text, response=True) |
| if mano_response.status_code==200: |
| return content |
| else: |
| raise OpenmanoResponseException(str(content)) |
| |
| def _edit_item(self, item, descriptor, uuid=None, name=None, all_tenants=False): |
| if all_tenants: |
| tenant_text = "/any" |
| elif all_tenants==None: |
| tenant_text = "" |
| else: |
| tenant_text = "/"+self._get_tenant() |
| |
| if not uuid: |
| #check that exist |
| uuid = self._get_item_uuid("tenants", uuid, name, all_tenants) |
| |
| payload_req = yaml.safe_dump(descriptor) |
| |
| #print payload_req |
| |
| URLrequest = "{}{}/{}/{}".format(self.endpoint_url, tenant_text, item, uuid) |
| self.logger.debug("openmano PUT %s %s", URLrequest, payload_req) |
| mano_response = requests.put(URLrequest, headers = self.headers_req, data=payload_req) |
| self.logger.debug("openmano response: %s", mano_response.text ) |
| |
| content = self._parse_yaml(mano_response.text, response=True) |
| if mano_response.status_code==200: |
| return content |
| else: |
| raise OpenmanoResponseException(str(content)) |
| |
| #TENANTS |
| def list_tenants(self, **kwargs): |
| '''Obtain a list of tenants |
| Params: can be filtered by 'uuid','name','description' |
| Return: Raises an exception on error |
| Obtain a dictionary with format {'tenants':[{tenant1_info},{tenant2_info},...]}} |
| ''' |
| return self._list_item("tenants", all_tenants=None, filter_dict=kwargs) |
| |
| def get_tenant(self, uuid=None, name=None): |
| '''Obtain the information of a tenant |
| Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| Return: Raises an exception on error, not found, found several |
| Obtain a dictionary with format {'tenant':{tenant_info}} |
| ''' |
| return self._get_item("tenants", uuid, name, all_tenants=None) |
| |
| def delete_tenant(self, uuid=None, name=None): |
| '''Delete a tenant |
| Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| Return: Raises an exception on error, not found, found several |
| Obtain a dictionary with format {'result': text indicating deleted} |
| ''' |
| return self._del_item("tenants", uuid, name, all_tenants=None) |
| |
| def create_tenant(self, descriptor=None, descriptor_format=None, name=None, description=None): |
| '''Creates a tenant |
| Params: must supply a descriptor or/and just a name |
| descriptor: with format {'tenant':{new_tenant_info}} |
| newtenant_info must contain 'name', and optionally 'description' |
| must be a dictionary or a json/yaml text. |
| name: the tenant name. Overwrite descriptor name if any |
| description: tenant descriptor.. Overwrite descriptor description if any |
| Return: Raises an exception on error |
| Obtain a dictionary with format {'tenant':{new_tenant_info}} |
| ''' |
| if isinstance(descriptor, str): |
| descriptor = self._parse(descriptor, descriptor_format) |
| elif descriptor: |
| pass |
| elif name: |
| descriptor={"tenant": {"name": name}} |
| else: |
| raise OpenmanoBadParamsException("Missing descriptor") |
| |
| if 'tenant' not in descriptor or len(descriptor)!=1: |
| raise OpenmanoBadParamsException("Descriptor must contain only one 'tenant' field") |
| if name: |
| descriptor['tenant']['name'] = name |
| if description: |
| descriptor['tenant']['description'] = description |
| |
| return self._create_item("tenants", descriptor, all_tenants=None) |
| |
| def edit_tenant(self, uuid=None, name=None, descriptor=None, descriptor_format=None, new_name=None, new_description=None): |
| '''Edit the parameters of a tenant |
| Params: must supply a descriptor or/and a new_name or new_description |
| uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| descriptor: with format {'tenant':{params to change info}} |
| must be a dictionary or a json/yaml text. |
| name: the tenant name. Overwrite descriptor name if any |
| description: tenant descriptor.. Overwrite descriptor description if any |
| Return: Raises an exception on error, not found or found several |
| Obtain a dictionary with format {'tenant':{newtenant_info}} |
| ''' |
| |
| if isinstance(descriptor, str): |
| descriptor = self.parse(descriptor, descriptor_format) |
| elif descriptor: |
| pass |
| elif new_name or new_description: |
| descriptor={"tenant": {}} |
| else: |
| raise OpenmanoBadParamsException("Missing descriptor") |
| |
| if 'tenant' not in descriptor or len(descriptor)!=1: |
| raise OpenmanoBadParamsException("Descriptor must contain only one 'tenant' field") |
| if new_name: |
| descriptor['tenant']['name'] = new_name |
| if new_description: |
| descriptor['tenant']['description'] = new_description |
| |
| return self._edit_item("tenants", descriptor, uuid, name, all_tenants=None) |
| |
| #DATACENTERS |
| |
| def list_datacenters(self, all_tenants=False, **kwargs): |
| '''Obtain a list of datacenters, that are the VIM information at openmano |
| Params: can be filtered by 'uuid','name','vim_url','type' |
| Return: Raises an exception on error |
| Obtain a dictionary with format {'datacenters':[{datacenter1_info},{datacenter2_info},...]}} |
| ''' |
| return self._list_item("datacenters", all_tenants, filter_dict=kwargs) |
| |
| def get_datacenter(self, uuid=None, name=None, all_tenants=False): |
| '''Obtain the information of a datacenter |
| Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| Return: Raises an exception on error, not found, found several |
| Obtain a dictionary with format {'datacenter':{datacenter_info}} |
| ''' |
| return self._get_item("datacenters", uuid, name, all_tenants) |
| |
| def delete_datacenter(self, uuid=None, name=None): |
| '''Delete a datacenter |
| Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| Return: Raises an exception on error, not found, found several, not free |
| Obtain a dictionary with format {'result': text indicating deleted} |
| ''' |
| if not uuid: |
| # check that exist |
| uuid = self._get_item_uuid("datacenters", uuid, name, all_tenants=True) |
| return self._del_item("datacenters", uuid, name, all_tenants=None) |
| |
| def create_datacenter(self, descriptor=None, descriptor_format=None, name=None, vim_url=None, **kwargs): |
| #, type="openvim", public=False, description=None): |
| '''Creates a datacenter |
| Params: must supply a descriptor or/and just a name and vim_url |
| descriptor: with format {'datacenter':{new_datacenter_info}} |
| newdatacenter_info must contain 'name', 'vim_url', and optionally 'description' |
| must be a dictionary or a json/yaml text. |
| name: the datacenter name. Overwrite descriptor name if any |
| vim_url: the datacenter URL. Overwrite descriptor vim_url if any |
| vim_url_admin: the datacenter URL for administrative issues. Overwrite descriptor vim_url if any |
| vim_type: the datacenter type, can be openstack or openvim. Overwrite descriptor type if any |
| public: boolean, by default not public |
| description: datacenter description. Overwrite descriptor description if any |
| config: dictionary with extra configuration for the concrete datacenter |
| Return: Raises an exception on error |
| Obtain a dictionary with format {'datacenter':{new_datacenter_info}} |
| ''' |
| if isinstance(descriptor, str): |
| descriptor = self.parse(descriptor, descriptor_format) |
| elif descriptor: |
| pass |
| elif name and vim_url: |
| descriptor={"datacenter": {"name": name, "vim_url": vim_url}} |
| else: |
| raise OpenmanoBadParamsException("Missing descriptor, or name and vim_url") |
| |
| if 'datacenter' not in descriptor or len(descriptor)!=1: |
| raise OpenmanoBadParamsException("Descriptor must contain only one 'datacenter' field") |
| if name: |
| descriptor['datacenter']['name'] = name |
| if vim_url: |
| descriptor['datacenter']['vim_url'] = vim_url |
| for param in kwargs: |
| descriptor['datacenter'][param] = kwargs[param] |
| |
| return self._create_item("datacenters", descriptor, all_tenants=None) |
| |
| def edit_datacenter(self, uuid=None, name=None, descriptor=None, descriptor_format=None, all_tenants=False, **kwargs): |
| '''Edit the parameters of a datacenter |
| Params: must supply a descriptor or/and a parameter to change |
| uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| descriptor: with format {'datacenter':{params to change info}} |
| must be a dictionary or a json/yaml text. |
| parameters to change can be supplyied by the descriptor or as parameters: |
| new_name: the datacenter name |
| vim_url: the datacenter URL |
| vim_url_admin: the datacenter URL for administrative issues |
| vim_type: the datacenter type, can be openstack or openvim. |
| public: boolean, available to other tenants |
| description: datacenter description |
| Return: Raises an exception on error, not found or found several |
| Obtain a dictionary with format {'datacenter':{new_datacenter_info}} |
| ''' |
| |
| if isinstance(descriptor, str): |
| descriptor = self.parse(descriptor, descriptor_format) |
| elif descriptor: |
| pass |
| elif kwargs: |
| descriptor={"datacenter": {}} |
| else: |
| raise OpenmanoBadParamsException("Missing descriptor") |
| |
| if 'datacenter' not in descriptor or len(descriptor)!=1: |
| raise OpenmanoBadParamsException("Descriptor must contain only one 'datacenter' field") |
| for param in kwargs: |
| if param=='new_name': |
| descriptor['datacenter']['name'] = kwargs[param] |
| else: |
| descriptor['datacenter'][param] = kwargs[param] |
| return self._edit_item("datacenters", descriptor, uuid, name, all_tenants=None) |
| |
| def attach_datacenter(self, uuid=None, name=None, descriptor=None, descriptor_format=None, vim_user=None, vim_password=None, vim_tenant_name=None, vim_tenant_id=None): |
| #check that exist |
| uuid = self._get_item_uuid("datacenters", uuid, name, all_tenants=True) |
| tenant_text = "/"+self._get_tenant() |
| |
| if isinstance(descriptor, str): |
| descriptor = self.parse(descriptor, descriptor_format) |
| elif descriptor: |
| pass |
| elif vim_user or vim_password or vim_tenant_name or vim_tenant_id: |
| descriptor={"datacenter": {}} |
| else: |
| raise OpenmanoBadParamsException("Missing descriptor or params") |
| |
| if vim_user or vim_password or vim_tenant_name or vim_tenant_id: |
| #print args.name |
| try: |
| if vim_user: |
| descriptor['datacenter']['vim_user'] = vim_user |
| if vim_password: |
| descriptor['datacenter']['vim_password'] = vim_password |
| if vim_tenant_name: |
| descriptor['datacenter']['vim_tenant_name'] = vim_tenant_name |
| if vim_tenant_id: |
| descriptor['datacenter']['vim_tenant'] = vim_tenant_id |
| except (KeyError, TypeError) as e: |
| if str(e)=='datacenter': error_pos= "missing field 'datacenter'" |
| else: error_pos="wrong format" |
| raise OpenmanoBadParamsException("Wrong datacenter descriptor: " + error_pos) |
| |
| payload_req = yaml.safe_dump(descriptor) |
| #print payload_req |
| URLrequest = "{}{}/datacenters/{}".format(self.endpoint_url, tenant_text, uuid) |
| self.logger.debug("openmano POST %s %s", URLrequest, payload_req) |
| mano_response = requests.post(URLrequest, headers = self.headers_req, data=payload_req) |
| self.logger.debug("openmano response: %s", mano_response.text ) |
| |
| content = self._parse_yaml(mano_response.text, response=True) |
| if mano_response.status_code==200: |
| return content |
| else: |
| raise OpenmanoResponseException(str(content)) |
| |
| def detach_datacenter(self, uuid=None, name=None): |
| if not uuid: |
| #check that exist |
| uuid = self._get_item_uuid("datacenters", uuid, name, all_tenants=False) |
| tenant_text = "/"+self._get_tenant() |
| URLrequest = "{}{}/datacenters/{}".format(self.endpoint_url, tenant_text, uuid) |
| self.logger.debug("openmano DELETE %s", URLrequest) |
| mano_response = requests.delete(URLrequest, headers = self.headers_req) |
| self.logger.debug("openmano response: %s", mano_response.text ) |
| |
| content = self._parse_yaml(mano_response.text, response=True) |
| if mano_response.status_code==200: |
| return content |
| else: |
| raise OpenmanoResponseException(str(content)) |
| |
| # WIMS |
| |
| def list_wims(self, all_tenants=False, **kwargs): |
| '''Obtain a list of wims, that are the WIM information at openmano |
| Params: can be filtered by 'uuid','name','wim_url','type' |
| Return: Raises an exception on error |
| Obtain a dictionary with format {'wims':[{wim1_info},{wim2_info},...]}} |
| ''' |
| return self._list_item("wims", all_tenants, filter_dict=kwargs) |
| |
| def get_wim(self, uuid=None, name=None, all_tenants=False): |
| '''Obtain the information of a wim |
| Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| Return: Raises an exception on error, not found, found several |
| Obtain a dictionary with format {'wim':{wim_info}} |
| ''' |
| return self._get_item("wims", uuid, name, all_tenants) |
| |
| def delete_wim(self, uuid=None, name=None): |
| '''Delete a wim |
| Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| Return: Raises an exception on error, not found, found several, not free |
| Obtain a dictionary with format {'result': text indicating deleted} |
| ''' |
| if not uuid: |
| # check that exist |
| uuid = self._get_item_uuid("wims", uuid, name, all_tenants=True) |
| return self._del_item("wims", uuid, name, all_tenants=None) |
| |
| def create_wim(self, descriptor=None, descriptor_format=None, name=None, wim_url=None, **kwargs): |
| # , type="openvim", public=False, description=None): |
| '''Creates a wim |
| Params: must supply a descriptor or/and just a name and a wim_url |
| descriptor: with format {'wim':{new_wim_info}} |
| new_wim_info must contain 'name', 'wim_url', and optionally 'description' |
| must be a dictionary or a json/yaml text. |
| name: the wim name. Overwrite descriptor name if any |
| wim_url: the wim URL. Overwrite descriptor vim_url if any |
| wim_type: the WIM type, can be tapi, odl, onos. Overwrite descriptor type if any |
| public: boolean, by default not public |
| description: wim description. Overwrite descriptor description if any |
| config: dictionary with extra configuration for the concrete wim |
| Return: Raises an exception on error |
| Obtain a dictionary with format {'wim:{new_wim_info}} |
| ''' |
| if isinstance(descriptor, str): |
| descriptor = self.parse(descriptor, descriptor_format) |
| elif descriptor: |
| pass |
| elif name and wim_url: |
| descriptor = {"wim": {"name": name, "wim_url": wim_url}} |
| else: |
| raise OpenmanoBadParamsException("Missing descriptor, or name and wim_url") |
| |
| if 'wim' not in descriptor or len(descriptor) != 1: |
| raise OpenmanoBadParamsException("Descriptor must contain only one 'wim' field") |
| if name: |
| descriptor['wim']['name'] = name |
| if wim_url: |
| descriptor['wim']['wim_url'] = wim_url |
| for param in kwargs: |
| descriptor['wim'][param] = kwargs[param] |
| |
| return self._create_item("wims", descriptor, all_tenants=None) |
| |
| def edit_wim(self, uuid=None, name=None, descriptor=None, descriptor_format=None, all_tenants=False, |
| **kwargs): |
| '''Edit the parameters of a wim |
| Params: must supply a descriptor or/and a parameter to change |
| uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| descriptor: with format {'wim':{params to change info}} |
| must be a dictionary or a json/yaml text. |
| parameters to change can be supplied by the descriptor or as parameters: |
| new_name: the wim name |
| wim_url: the wim URL |
| wim_type: the wim type, can be tapi, onos, odl |
| public: boolean, available to other tenants |
| description: wim description |
| Return: Raises an exception on error, not found or found several |
| Obtain a dictionary with format {'wim':{new_wim_info}} |
| ''' |
| if isinstance(descriptor, str): |
| descriptor = self.parse(descriptor, descriptor_format) |
| elif descriptor: |
| pass |
| elif kwargs: |
| descriptor = {"wim": {}} |
| else: |
| raise OpenmanoBadParamsException("Missing descriptor") |
| |
| if 'wim' not in descriptor or len(descriptor) != 1: |
| raise OpenmanoBadParamsException("Descriptor must contain only one 'wim' field") |
| for param in kwargs: |
| if param == 'new_name': |
| descriptor['wim']['name'] = kwargs[param] |
| else: |
| descriptor['wim'][param] = kwargs[param] |
| return self._edit_item("wims", descriptor, uuid, name, all_tenants=None) |
| |
| def attach_wim(self, uuid=None, name=None, descriptor=None, descriptor_format=None, wim_user=None, |
| wim_password=None, wim_tenant_name=None, wim_tenant_id=None): |
| # check that exist |
| uuid = self._get_item_uuid("wims", uuid, name, all_tenants=True) |
| tenant_text = "/" + self._get_tenant() |
| |
| if isinstance(descriptor, str): |
| descriptor = self.parse(descriptor, descriptor_format) |
| elif descriptor: |
| pass |
| elif wim_user or wim_password or wim_tenant_name or wim_tenant_id: |
| descriptor = {"wim": {}} |
| else: |
| raise OpenmanoBadParamsException("Missing descriptor or params") |
| |
| if wim_user or wim_password or wim_tenant_name or wim_tenant_id: |
| # print args.name |
| try: |
| if wim_user: |
| descriptor['wim']['wim_user'] = wim_user |
| if wim_password: |
| descriptor['wim']['wim_password'] = wim_password |
| if wim_tenant_name: |
| descriptor['wim']['wim_tenant_name'] = wim_tenant_name |
| if wim_tenant_id: |
| descriptor['wim']['wim_tenant'] = wim_tenant_id |
| except (KeyError, TypeError) as e: |
| if str(e) == 'wim': |
| error_pos = "missing field 'wim'" |
| else: |
| error_pos = "wrong format" |
| raise OpenmanoBadParamsException("Wrong wim descriptor: " + error_pos) |
| |
| payload_req = yaml.safe_dump(descriptor) |
| # print payload_req |
| URLrequest = "{}{}/wims/{}".format(self.endpoint_url, tenant_text, uuid) |
| self.logger.debug("openmano POST %s %s", URLrequest, payload_req) |
| mano_response = requests.post(URLrequest, headers=self.headers_req, data=payload_req) |
| self.logger.debug("openmano response: %s", mano_response.text) |
| |
| content = self._parse_yaml(mano_response.text, response=True) |
| if mano_response.status_code == 200: |
| return content |
| else: |
| raise OpenmanoResponseException(str(content)) |
| |
| def detach_wim(self, uuid=None, name=None): |
| if not uuid: |
| # check that exist |
| uuid = self._get_item_uuid("wims", uuid, name, all_tenants=False) |
| tenant_text = "/" + self._get_tenant() |
| URLrequest = "{}{}/wims/{}".format(self.endpoint_url, tenant_text, uuid) |
| self.logger.debug("openmano DELETE %s", URLrequest) |
| mano_response = requests.delete(URLrequest, headers=self.headers_req) |
| self.logger.debug("openmano response: %s", mano_response.text) |
| |
| content = self._parse_yaml(mano_response.text, response=True) |
| if mano_response.status_code == 200: |
| return content |
| else: |
| raise OpenmanoResponseException(str(content)) |
| |
| #VNFS |
| def list_vnfs(self, all_tenants=False, **kwargs): |
| '''Obtain a list of vnfs |
| Params: can be filtered by 'uuid','name','description','public', "tenant_id" |
| Return: Raises an exception on error |
| Obtain a dictionary with format {'vnfs':[{vnf1_info},{vnf2_info},...]}} |
| ''' |
| return self._list_item("vnfs", all_tenants, kwargs) |
| |
| def get_vnf(self, uuid=None, name=None, all_tenants=False): |
| '''Obtain the information of a vnf |
| Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| Return: Raises an exception on error, not found, found several |
| Obtain a dictionary with format {'vnf':{vnf_info}} |
| ''' |
| return self._get_item("vnfs", uuid, name, all_tenants) |
| |
| def delete_vnf(self, uuid=None, name=None, all_tenants=False): |
| '''Delete a vnf |
| Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| Return: Raises an exception on error, not found, found several, not free |
| Obtain a dictionary with format {'result': text indicating deleted} |
| ''' |
| return self._del_item("vnfs", uuid, name, all_tenants) |
| |
| def create_vnf(self, descriptor=None, descriptor_format=None, **kwargs): |
| '''Creates a vnf |
| Params: must supply a descriptor |
| descriptor: with format {'vnf':{new_vnf_info}} |
| must be a dictionary or a json/yaml text. |
| must be a dictionary or a json/yaml text. |
| Other parameters can be: |
| #TODO, revise |
| name: the vnf name. Overwrite descriptor name if any |
| image_path: Can be a string or a string list. Overwrite the image_path at descriptor |
| description: vnf descriptor.. Overwrite descriptor description if any |
| public: boolean, available to other tenants |
| class: user text for vnf classification |
| tenant_id: Propietary tenant |
| ... |
| Return: Raises an exception on error |
| Obtain a dictionary with format {'vnf':{new_vnf_info}} |
| ''' |
| if isinstance(descriptor, str): |
| descriptor = self.parse(descriptor, descriptor_format) |
| elif descriptor: |
| pass |
| else: |
| raise OpenmanoBadParamsException("Missing descriptor") |
| |
| try: |
| if "vnfd:vnfd-catalog" in descriptor or "vnfd-catalog" in descriptor: |
| api_version = "v3" |
| token = "vnfd" |
| vnfd_catalog = descriptor.get("vnfd:vnfd-catalog") |
| if not vnfd_catalog: |
| vnfd_catalog = descriptor.get("vnfd-catalog") |
| vnfds = vnfd_catalog.get("vnfd:vnfd") |
| if not vnfds: |
| vnfds = vnfd_catalog.get("vnfd") |
| vnfd = vnfds[0] |
| vdu_list = vnfd["vdu"] |
| elif "vnf" in descriptor: # old API |
| api_version = None |
| token = "vnfs" |
| vnfd = descriptor['vnf'] |
| vdu_list = vnfd["VNFC"] |
| else: |
| raise OpenmanoBadParamsException("Invalid VNF Descriptor must contain only one 'vnf' field or vnd-catalog") |
| except (KeyError, TypeError) as e: |
| raise OpenmanoBadParamsException("Invalid VNF Descriptor. Missing field {}".format(e)) |
| |
| if kwargs: |
| try: |
| if kwargs.get('name'): |
| vnfd['name'] = kwargs['name'] |
| if kwargs.get('description'): |
| vnfd['description'] = kwargs['description'] |
| if kwargs.get('image_path'): |
| error_param = 'image_path' |
| image_list = kwargs['image_path'].split(",") |
| image_item = image_list.pop(0) |
| # print "image-path", image_path_ |
| for vdu in vdu_list: |
| if api_version == "v3": |
| if vdu.get("image"): |
| if image_item: |
| vdu['image'] = image_item |
| if "image-checksum" in vdu: |
| del vdu["image-checksum"] |
| if image_list: |
| image_item = image_list.pop(0) |
| for vol in vdu.get("volumes", ()): # image name in volumes |
| if image_item: |
| vol["image"] = image_item |
| if "image-checksum" in vol: |
| del vol["image-checksum"] |
| if image_list: |
| image_item = image_list.pop(0) |
| else: |
| if image_item: |
| vdu['VNFC image'] = image_item |
| if "image name" in vdu: |
| del vdu["image name"] |
| if "image checksum" in vdu: |
| del vdu["image checksum"] |
| if image_list: |
| image_item = image_list.pop(0) |
| for vol in vdu.get('devices', ()): |
| if vol['type'] != 'disk': |
| continue |
| if image_item: |
| vol['image'] = image_item |
| if "image name" in vol: |
| del vol["image name"] |
| if "image checksum" in vol: |
| del vol["image checksum"] |
| if image_list: |
| image_item = image_list.pop(0) |
| if kwargs.get('image_name'): # image name precedes if both are supplied |
| error_param = 'image_name' |
| image_list = kwargs['image_name'].split(",") |
| image_item = image_list.pop(0) |
| for vdu in vdu_list: |
| if api_version == "v3": |
| if vdu.get("image"): |
| if image_item: |
| vdu['image'] = image_item |
| if "image-checksum" in vdu: |
| del vdu["image-checksum"] |
| if image_list: |
| image_item = image_list.pop(0) |
| for vol in vdu.get("volumes", ()): # image name in volumes |
| if image_item: |
| vol["image"] = image_item |
| if "image-checksum" in vol: |
| del vol["image-checksum"] |
| if image_list: |
| image_item = image_list.pop(0) |
| else: |
| if image_item: |
| vdu['image name'] = image_item |
| if "VNFC image" in vdu: |
| del vdu["VNFC image"] |
| if image_list: |
| image_item = image_list.pop(0) |
| for vol in vdu.get('devices', ()): |
| if vol['type'] != 'disk': |
| continue |
| if image_item: |
| vol['image name'] = image_item |
| if "image" in vol: |
| del vol["image"] |
| if "image checksum" in vol: |
| del vol["image checksum"] |
| if image_list: |
| image_item = image_list.pop(0) |
| |
| if kwargs.get('image_checksum'): |
| error_param = 'image_checksum' |
| image_list = kwargs['image_checksum'].split(",") |
| image_item = image_list.pop(0) |
| for vdu in vdu_list: |
| if api_version == "v3": |
| if vdu.get("image"): |
| if image_item: |
| vdu['image-checksum'] = image_item |
| if image_list: |
| image_item = image_list.pop(0) |
| for vol in vdu.get("volumes", ()): # image name in volumes |
| if image_item: |
| vol["mage-checksum"] = image_item |
| if image_list: |
| image_item = image_list.pop(0) |
| else: |
| if image_item: |
| vdu['image checksum'] = image_item |
| if "VNFC image" in vdu: |
| del vdu["VNFC image"] |
| if image_list: |
| image_item = image_list.pop(0) |
| for vol in vdu.get('devices', ()): |
| if vol['type'] != 'disk': |
| continue |
| if image_item: |
| vol['image checksum'] = image_item |
| if "image" in vol: |
| del vol["image"] |
| if image_list: |
| image_item = image_list.pop(0) |
| except IndexError: |
| raise OpenmanoBadParamsException("{} contains more items than {} at descriptor".format( |
| error_param, "vnfd-catalog:vnfd:vdu" if api_version else "vnf:VNFC")) |
| except (KeyError, TypeError) as e: |
| raise OpenmanoBadParamsException("Invalid VNF Descriptor. Missing field {}".format(e)) |
| return self._create_item(token, descriptor, api_version=api_version) |
| |
| # def edit_vnf(self, uuid=None, name=None, descriptor=None, descriptor_format=None, all_tenants=False, **kwargs): |
| # '''Edit the parameters of a vnf |
| # Params: must supply a descriptor or/and a parameters to change |
| # uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| # descriptor: with format {'vnf':{params to change info}} |
| # parameters to change can be supplyied by the descriptor or as parameters: |
| # new_name: the vnf name |
| # vim_url: the vnf URL |
| # vim_url_admin: the vnf URL for administrative issues |
| # vim_type: the vnf type, can be openstack or openvim. |
| # public: boolean, available to other tenants |
| # description: vnf description |
| # Return: Raises an exception on error, not found or found several |
| # Obtain a dictionary with format {'vnf':{new_vnf_info}} |
| # ''' |
| # |
| # if isinstance(descriptor, str): |
| # descriptor = self.parse(descriptor, descriptor_format) |
| # elif descriptor: |
| # pass |
| # elif kwargs: |
| # descriptor={"vnf": {}} |
| # else: |
| # raise OpenmanoBadParamsException("Missing descriptor") |
| # |
| # if 'vnf' not in descriptor or len(descriptor)>2: |
| # raise OpenmanoBadParamsException("Descriptor must contain only one 'vnf' field") |
| # for param in kwargs: |
| # if param=='new_name': |
| # descriptor['vnf']['name'] = kwargs[param] |
| # else: |
| # descriptor['vnf'][param] = kwargs[param] |
| # return self._edit_item("vnfs", descriptor, uuid, name, all_tenants=None) |
| |
| #SCENARIOS |
| def list_scenarios(self, all_tenants=False, **kwargs): |
| '''Obtain a list of scenarios |
| Params: can be filtered by 'uuid','name','description','public', "tenant_id" |
| Return: Raises an exception on error |
| Obtain a dictionary with format {'scenarios':[{scenario1_info},{scenario2_info},...]}} |
| ''' |
| return self._list_item("scenarios", all_tenants, kwargs) |
| |
| def get_scenario(self, uuid=None, name=None, all_tenants=False): |
| '''Obtain the information of a scenario |
| Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| Return: Raises an exception on error, not found, found several |
| Obtain a dictionary with format {'scenario':{scenario_info}} |
| ''' |
| return self._get_item("scenarios", uuid, name, all_tenants) |
| |
| def delete_scenario(self, uuid=None, name=None, all_tenants=False): |
| '''Delete a scenario |
| Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| Return: Raises an exception on error, not found, found several, not free |
| Obtain a dictionary with format {'result': text indicating deleted} |
| ''' |
| return self._del_item("scenarios", uuid, name, all_tenants) |
| |
| def create_scenario(self, descriptor=None, descriptor_format=None, **kwargs): |
| """Creates a scenario |
| Params: must supply a descriptor |
| descriptor: with format {'scenario':{new_scenario_info}} |
| must be a dictionary or a json/yaml text. |
| Other parameters can be: |
| name: the scenario name. Overwrite descriptor name if any |
| description: scenario descriptor.. Overwrite descriptor description if any |
| public: boolean, available to other tenants |
| tenant_id. Propietary tenant |
| Return: Raises an exception on error |
| Obtain a dictionary with format {'scenario':{new_scenario_info}} |
| """ |
| if isinstance(descriptor, str): |
| descriptor = self.parse(descriptor, descriptor_format) |
| elif descriptor: |
| pass |
| else: |
| raise OpenmanoBadParamsException("Missing descriptor") |
| |
| try: |
| if "nsd:nsd-catalog" in descriptor or "nsd-catalog" in descriptor: |
| api_version = "v3" |
| token = "nsd" |
| nsd_catalog = descriptor.get("nsd:nsd-catalog") |
| if not nsd_catalog: |
| nsd_catalog = descriptor.get("nsd-catalog") |
| nsds = nsd_catalog.get("nsd:nsd") |
| if not nsds: |
| nsds = nsd_catalog.get("nsd") |
| nsd = nsds[0] |
| elif "scenario" in descriptor: # old API |
| api_version = None |
| token = "scenarios" |
| nsd = descriptor['scenario'] |
| else: |
| raise OpenmanoBadParamsException("Invalid NS Descriptor must contain only one 'scenario' field or nsd-catalog") |
| except (KeyError, TypeError) as e: |
| raise OpenmanoBadParamsException("Invalid NS Descriptor. Missing field {}".format(e)) |
| |
| for param in kwargs: |
| nsd[param] = kwargs[param] |
| return self._create_item(token, descriptor, api_version=api_version) |
| |
| def edit_scenario(self, uuid=None, name=None, descriptor=None, descriptor_format=None, all_tenants=False, **kwargs): |
| '''Edit the parameters of a scenario |
| Params: must supply a descriptor or/and a parameters to change |
| uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| descriptor: with format {'scenario':{params to change info}} |
| must be a dictionary or a json/yaml text. |
| parameters to change can be supplyied by the descriptor or as parameters: |
| new_name: the scenario name |
| public: boolean, available to other tenants |
| description: scenario description |
| tenant_id. Propietary tenant |
| Return: Raises an exception on error, not found or found several |
| Obtain a dictionary with format {'scenario':{new_scenario_info}} |
| ''' |
| |
| if isinstance(descriptor, str): |
| descriptor = self.parse(descriptor, descriptor_format) |
| elif descriptor: |
| pass |
| elif kwargs: |
| descriptor={"scenario": {}} |
| else: |
| raise OpenmanoBadParamsException("Missing descriptor") |
| |
| if 'scenario' not in descriptor or len(descriptor)>2: |
| raise OpenmanoBadParamsException("Descriptor must contain only one 'scenario' field") |
| for param in kwargs: |
| if param=='new_name': |
| descriptor['scenario']['name'] = kwargs[param] |
| else: |
| descriptor['scenario'][param] = kwargs[param] |
| return self._edit_item("scenarios", descriptor, uuid, name, all_tenants=None) |
| |
| |
| #INSTANCE-SCENARIOS |
| def list_instances(self, all_tenants=False, **kwargs): |
| '''Obtain a list of instances |
| Params: can be filtered by 'uuid','name','description','scenario_id', "tenant_id" |
| Return: Raises an exception on error |
| Obtain a dictionary with format {'instances':[{instance1_info},{instance2_info},...]}} |
| ''' |
| return self._list_item("instances", all_tenants, kwargs) |
| |
| def get_instance(self, uuid=None, name=None, all_tenants=False): |
| '''Obtain the information of a instance |
| Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| Return: Raises an exception on error, not found, found several |
| Obtain a dictionary with format {'instance':{instance_info}} |
| ''' |
| return self._get_item("instances", uuid, name, all_tenants) |
| |
| def delete_instance(self, uuid=None, name=None, all_tenants=False): |
| '''Delete a instance |
| Params: uuid or/and name. If only name is supplied, there must be only one or an exception is raised |
| Return: Raises an exception on error, not found, found several, not free |
| Obtain a dictionary with format {'result': text indicating deleted} |
| ''' |
| return self._del_item("instances", uuid, name, all_tenants) |
| |
| def create_instance(self, descriptor=None, descriptor_format=None, name=None, **kwargs): |
| '''Creates a instance |
| Params: must supply a descriptor or/and a name and scenario |
| descriptor: with format {'instance':{new_instance_info}} |
| must be a dictionary or a json/yaml text. |
| name: the instance name. Overwrite descriptor name if any |
| Other parameters can be: |
| description: instance descriptor.. Overwrite descriptor description if any |
| datacenter_name, datacenter_id: datacenter where to be deployed |
| scenario_name, scenario_id: Scenario this instance is based on |
| Return: Raises an exception on error |
| Obtain a dictionary with format {'instance':{new_instance_info}} |
| ''' |
| if isinstance(descriptor, str): |
| descriptor = self.parse(descriptor, descriptor_format) |
| elif descriptor: |
| pass |
| elif name and ("scenario_name" in kwargs or "scenario_id" in kwargs): |
| descriptor = {"instance": {"name": name}} |
| else: |
| raise OpenmanoBadParamsException("Missing descriptor") |
| |
| if 'instance' not in descriptor or len(descriptor)>2: |
| raise OpenmanoBadParamsException("Descriptor must contain only one 'instance' field, and an optional version") |
| if name: |
| descriptor['instance']["name"] = name |
| if "scenario_name" in kwargs or "scenario_id" in kwargs: |
| descriptor['instance']["scenario"] = self._get_item_uuid("scenarios", kwargs.get("scenario_id"), kwargs.get("scenario_name")) |
| if "datacenter_name" in kwargs or "datacenter_id" in kwargs: |
| descriptor['instance']["datacenter"] = self._get_item_uuid("datacenters", kwargs.get("datacenter_id"), kwargs.get("datacenter_name")) |
| if "description" in kwargs: |
| descriptor['instance']["description"] = kwargs.get("description") |
| #for param in kwargs: |
| # descriptor['instance'][param] = kwargs[param] |
| if "datacenter" not in descriptor['instance']: |
| descriptor['instance']["datacenter"] = self._get_datacenter() |
| return self._create_item("instances", descriptor) |
| |
| #VIM ACTIONS |
| def vim_action(self, action, item, uuid=None, all_tenants=False, **kwargs): |
| '''Perform an action over a vim |
| Params: |
| action: can be 'list', 'get'/'show', 'delete' or 'create' |
| item: can be 'tenants' or 'networks' |
| uuid: uuid of the tenant/net to show or to delete. Ignore otherwise |
| other parameters: |
| datacenter_name, datacenter_id: datacenters to act on, if missing uses classes store datacenter |
| descriptor, descriptor_format: descriptor needed on creation, can be a dict or a yaml/json str |
| must be a dictionary or a json/yaml text. |
| name: for created tenant/net Overwrite descriptor name if any |
| description: tenant descriptor. Overwrite descriptor description if any |
| |
| Return: Raises an exception on error |
| Obtain a dictionary with format {'tenant':{new_tenant_info}} |
| ''' |
| if item not in ("tenants", "networks", "images"): |
| raise OpenmanoBadParamsException("Unknown value for item '{}', must be 'tenants', 'nets' or " |
| "images".format(str(item))) |
| |
| image_actions = ['list','get','show','delete'] |
| if item == "images" and action not in image_actions: |
| raise OpenmanoBadParamsException("Only available actions for item '{}' are {}\n" |
| "Requested action was '{}'".format(item, ', '.join(image_actions), action)) |
| if all_tenants: |
| tenant_text = "/any" |
| else: |
| tenant_text = "/"+self._get_tenant() |
| |
| if "datacenter_id" in kwargs or "datacenter_name" in kwargs: |
| datacenter = self._get_item_uuid("datacenters", kwargs.get("datacenter_id"), kwargs.get("datacenter_name"), all_tenants=all_tenants) |
| else: |
| datacenter = self._get_datacenter() |
| |
| if action=="list": |
| URLrequest = "{}{}/vim/{}/{}".format(self.endpoint_url, tenant_text, datacenter, item) |
| self.logger.debug("GET %s", URLrequest ) |
| mano_response = requests.get(URLrequest, headers=self.headers_req) |
| self.logger.debug("openmano response: %s", mano_response.text ) |
| content = self._parse_yaml(mano_response.text, response=True) |
| if mano_response.status_code==200: |
| return content |
| else: |
| raise OpenmanoResponseException(str(content)) |
| elif action=="get" or action=="show": |
| URLrequest = "{}{}/vim/{}/{}/{}".format(self.endpoint_url, tenant_text, datacenter, item, uuid) |
| self.logger.debug("GET %s", URLrequest ) |
| mano_response = requests.get(URLrequest, headers=self.headers_req) |
| self.logger.debug("openmano response: %s", mano_response.text ) |
| content = self._parse_yaml(mano_response.text, response=True) |
| if mano_response.status_code==200: |
| return content |
| else: |
| raise OpenmanoResponseException(str(content)) |
| elif action=="delete": |
| URLrequest = "{}{}/vim/{}/{}/{}".format(self.endpoint_url, tenant_text, datacenter, item, uuid) |
| self.logger.debug("DELETE %s", URLrequest ) |
| mano_response = requests.delete(URLrequest, headers=self.headers_req) |
| self.logger.debug("openmano response: %s", mano_response.text ) |
| content = self._parse_yaml(mano_response.text, response=True) |
| if mano_response.status_code==200: |
| return content |
| else: |
| raise OpenmanoResponseException(str(content)) |
| elif action=="create": |
| if "descriptor" in kwargs: |
| if isinstance(kwargs["descriptor"], str): |
| descriptor = self._parse(kwargs["descriptor"], kwargs.get("descriptor_format") ) |
| else: |
| descriptor = kwargs["descriptor"] |
| elif "name" in kwargs: |
| descriptor={item[:-1]: {"name": kwargs["name"]}} |
| else: |
| raise OpenmanoResponseException("Missing descriptor") |
| |
| if item[:-1] not in descriptor or len(descriptor)!=1: |
| raise OpenmanoBadParamsException("Descriptor must contain only one 'tenant' field") |
| if "name" in kwargs: |
| descriptor[ item[:-1] ]['name'] = kwargs["name"] |
| if "description" in kwargs: |
| descriptor[ item[:-1] ]['description'] = kwargs["description"] |
| payload_req = yaml.safe_dump(descriptor) |
| #print payload_req |
| URLrequest = "{}{}/vim/{}/{}".format(self.endpoint_url, tenant_text, datacenter, item) |
| self.logger.debug("openmano POST %s %s", URLrequest, payload_req) |
| mano_response = requests.post(URLrequest, headers = self.headers_req, data=payload_req) |
| self.logger.debug("openmano response: %s", mano_response.text ) |
| content = self._parse_yaml(mano_response.text, response=True) |
| if mano_response.status_code==200: |
| return content |
| else: |
| raise OpenmanoResponseException(str(content)) |
| else: |
| raise OpenmanoBadParamsException("Unknown value for action '{}".format(str(action))) |
| |