+++ /dev/null
-# -*- 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
-##
-
-'''
-vimconnector implements all the methods to interact with openvim using the openvim API.
-'''
-__author__="Alfonso Tierno, Gerardo Garcia"
-__date__ ="$26-aug-2014 11:09:29$"
-
-import vimconn
-import requests
-import json
-import yaml
-import logging
-import math
-from openmano_schemas import id_schema, name_schema, nameshort_schema, description_schema, \
- vlan1000_schema, integer0_schema
-from jsonschema import validate as js_v, exceptions as js_e
-from urllib import quote
-
-'''contain the openvim virtual machine status to openmano status'''
-vmStatus2manoFormat={'ACTIVE':'ACTIVE',
- 'PAUSED':'PAUSED',
- 'SUSPENDED': 'SUSPENDED',
- 'INACTIVE':'INACTIVE',
- 'CREATING':'BUILD',
- 'ERROR':'ERROR','DELETED':'DELETED'
- }
-netStatus2manoFormat={'ACTIVE':'ACTIVE','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED', 'DOWN':'DOWN'
- }
-
-
-host_schema = {
- "type":"object",
- "properties":{
- "id": id_schema,
- "name": name_schema,
- },
- "required": ["id"]
-}
-image_schema = {
- "type":"object",
- "properties":{
- "id": id_schema,
- "name": name_schema,
- },
- "required": ["id","name"]
-}
-server_schema = {
- "type":"object",
- "properties":{
- "id":id_schema,
- "name": name_schema,
- },
- "required": ["id","name"]
-}
-new_host_response_schema = {
- "title":"host response information schema",
- "$schema": "http://json-schema.org/draft-04/schema#",
- "type":"object",
- "properties":{
- "host": host_schema
- },
- "required": ["host"],
- "additionalProperties": False
-}
-
-get_images_response_schema = {
- "title":"openvim images response information schema",
- "$schema": "http://json-schema.org/draft-04/schema#",
- "type":"object",
- "properties":{
- "images":{
- "type":"array",
- "items": image_schema,
- }
- },
- "required": ["images"],
- "additionalProperties": False
-}
-
-get_hosts_response_schema = {
- "title":"openvim hosts response information schema",
- "$schema": "http://json-schema.org/draft-04/schema#",
- "type":"object",
- "properties":{
- "hosts":{
- "type":"array",
- "items": host_schema,
- }
- },
- "required": ["hosts"],
- "additionalProperties": False
-}
-
-get_host_detail_response_schema = new_host_response_schema # TODO: Content is not parsed yet
-
-get_server_response_schema = {
- "title":"openvim server response information schema",
- "$schema": "http://json-schema.org/draft-04/schema#",
- "type":"object",
- "properties":{
- "servers":{
- "type":"array",
- "items": server_schema,
- }
- },
- "required": ["servers"],
- "additionalProperties": False
-}
-
-new_tenant_response_schema = {
- "title":"tenant response information schema",
- "$schema": "http://json-schema.org/draft-04/schema#",
- "type":"object",
- "properties":{
- "tenant":{
- "type":"object",
- "properties":{
- "id": id_schema,
- "name": nameshort_schema,
- "description":description_schema,
- "enabled":{"type" : "boolean"}
- },
- "required": ["id"]
- }
- },
- "required": ["tenant"],
- "additionalProperties": False
-}
-
-new_network_response_schema = {
- "title":"network response information schema",
- "$schema": "http://json-schema.org/draft-04/schema#",
- "type":"object",
- "properties":{
- "network":{
- "type":"object",
- "properties":{
- "id":id_schema,
- "name":name_schema,
- "type":{"type":"string", "enum":["bridge_man","bridge_data","data", "ptp"]},
- "shared":{"type":"boolean"},
- "tenant_id":id_schema,
- "admin_state_up":{"type":"boolean"},
- "vlan":vlan1000_schema
- },
- "required": ["id"]
- }
- },
- "required": ["network"],
- "additionalProperties": False
-}
-
-
-# get_network_response_schema = {
-# "title":"get network response information schema",
-# "$schema": "http://json-schema.org/draft-04/schema#",
-# "type":"object",
-# "properties":{
-# "network":{
-# "type":"object",
-# "properties":{
-# "id":id_schema,
-# "name":name_schema,
-# "type":{"type":"string", "enum":["bridge_man","bridge_data","data", "ptp"]},
-# "shared":{"type":"boolean"},
-# "tenant_id":id_schema,
-# "admin_state_up":{"type":"boolean"},
-# "vlan":vlan1000_schema
-# },
-# "required": ["id"]
-# }
-# },
-# "required": ["network"],
-# "additionalProperties": False
-# }
-
-
-new_port_response_schema = {
- "title":"port response information schema",
- "$schema": "http://json-schema.org/draft-04/schema#",
- "type":"object",
- "properties":{
- "port":{
- "type":"object",
- "properties":{
- "id":id_schema,
- },
- "required": ["id"]
- }
- },
- "required": ["port"],
- "additionalProperties": False
-}
-
-get_flavor_response_schema = {
- "title":"openvim flavors response information schema",
- "$schema": "http://json-schema.org/draft-04/schema#",
- "type":"object",
- "properties":{
- "flavor":{
- "type":"object",
- "properties":{
- "id": id_schema,
- "name": name_schema,
- "extended": {"type":"object"},
- },
- "required": ["id", "name"],
- }
- },
- "required": ["flavor"],
- "additionalProperties": False
-}
-
-new_flavor_response_schema = {
- "title":"flavor response information schema",
- "$schema": "http://json-schema.org/draft-04/schema#",
- "type":"object",
- "properties":{
- "flavor":{
- "type":"object",
- "properties":{
- "id":id_schema,
- },
- "required": ["id"]
- }
- },
- "required": ["flavor"],
- "additionalProperties": False
-}
-
-get_image_response_schema = {
- "title":"openvim images response information schema",
- "$schema": "http://json-schema.org/draft-04/schema#",
- "type":"object",
- "properties":{
- "image":{
- "type":"object",
- "properties":{
- "id": id_schema,
- "name": name_schema,
- },
- "required": ["id", "name"],
- }
- },
- "required": ["flavor"],
- "additionalProperties": False
-}
-new_image_response_schema = {
- "title":"image response information schema",
- "$schema": "http://json-schema.org/draft-04/schema#",
- "type":"object",
- "properties":{
- "image":{
- "type":"object",
- "properties":{
- "id":id_schema,
- },
- "required": ["id"]
- }
- },
- "required": ["image"],
- "additionalProperties": False
-}
-
-new_vminstance_response_schema = {
- "title":"server response information schema",
- "$schema": "http://json-schema.org/draft-04/schema#",
- "type":"object",
- "properties":{
- "server":{
- "type":"object",
- "properties":{
- "id":id_schema,
- },
- "required": ["id"]
- }
- },
- "required": ["server"],
- "additionalProperties": False
-}
-
-get_processor_rankings_response_schema = {
- "title":"processor rankings information schema",
- "$schema": "http://json-schema.org/draft-04/schema#",
- "type":"object",
- "properties":{
- "rankings":{
- "type":"array",
- "items":{
- "type":"object",
- "properties":{
- "model": description_schema,
- "value": integer0_schema
- },
- "additionalProperties": False,
- "required": ["model","value"]
- }
- },
- "additionalProperties": False,
- "required": ["rankings"]
- }
-}
-
-class vimconnector(vimconn.vimconnector):
- def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None,
- log_level="DEBUG", config={}, persistent_info={}):
- vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level, config)
- self.tenant = None
- self.headers_req = {'content-type': 'application/json'}
- self.logger = logging.getLogger('openmano.vim.openvim')
- self.persistent_info = persistent_info
- if tenant_id:
- self.tenant = tenant_id
-
- def __setitem__(self,index, value):
- '''Set individuals parameters
- Throw TypeError, KeyError
- '''
- if index=='tenant_id':
- self.tenant = value
- elif index=='tenant_name':
- self.tenant = None
- vimconn.vimconnector.__setitem__(self,index, value)
-
- def _get_my_tenant(self):
- '''Obtain uuid of my tenant from name
- '''
- if self.tenant:
- return self.tenant
-
- url = self.url+'/tenants?name='+ quote(self.tenant_name)
- self.logger.info("Getting VIM tenant_id GET %s", url)
- vim_response = requests.get(url, headers = self.headers_req)
- self._check_http_request_response(vim_response)
- try:
- tenant_list = vim_response.json()["tenants"]
- if len(tenant_list) == 0:
- raise vimconn.vimconnNotFoundException("No tenant found for name '%s'" % str(self.tenant_name))
- elif len(tenant_list) > 1:
- raise vimconn.vimconnConflictException ("More that one tenant found for name '%s'" % str(self.tenant_name))
- self.tenant = tenant_list[0]["id"]
- return self.tenant
- except Exception as e:
- raise vimconn.vimconnUnexpectedResponse("Get VIM tenant {} '{}'".format(type(e).__name__, str(e)))
-
- def _format_jsonerror(self,http_response):
- #DEPRECATED, to delete in the future
- try:
- data = http_response.json()
- return data["error"]["description"]
- except:
- return http_response.text
-
- def _format_in(self, http_response, schema):
- #DEPRECATED, to delete in the future
- try:
- client_data = http_response.json()
- js_v(client_data, schema)
- #print "Input data: ", str(client_data)
- return True, client_data
- except js_e.ValidationError as exc:
- print "validate_in error, jsonschema exception ", exc.message, "at", exc.path
- return False, ("validate_in error, jsonschema exception ", exc.message, "at", exc.path)
-
- def _remove_extra_items(self, data, schema):
- deleted=[]
- if type(data) is tuple or type(data) is list:
- for d in data:
- a= self._remove_extra_items(d, schema['items'])
- if a is not None: deleted.append(a)
- elif type(data) is dict:
- for k in data.keys():
- if 'properties' not in schema or k not in schema['properties'].keys():
- del data[k]
- deleted.append(k)
- else:
- a = self._remove_extra_items(data[k], schema['properties'][k])
- if a is not None: deleted.append({k:a})
- if len(deleted) == 0: return None
- elif len(deleted) == 1: return deleted[0]
- else: return deleted
-
- def _format_request_exception(self, request_exception):
- '''Transform a request exception into a vimconn exception'''
- if isinstance(request_exception, js_e.ValidationError):
- raise vimconn.vimconnUnexpectedResponse("jsonschema exception '{}' at '{}'".format(request_exception.message, request_exception.path))
- elif isinstance(request_exception, requests.exceptions.HTTPError):
- raise vimconn.vimconnUnexpectedResponse(type(request_exception).__name__ + ": " + str(request_exception))
- else:
- raise vimconn.vimconnConnectionException(type(request_exception).__name__ + ": " + str(request_exception))
-
- def _check_http_request_response(self, request_response):
- '''Raise a vimconn exception if the response is not Ok'''
- if request_response.status_code >= 200 and request_response.status_code < 300:
- return
- if request_response.status_code == vimconn.HTTP_Unauthorized:
- raise vimconn.vimconnAuthException(request_response.text)
- elif request_response.status_code == vimconn.HTTP_Not_Found:
- raise vimconn.vimconnNotFoundException(request_response.text)
- elif request_response.status_code == vimconn.HTTP_Conflict:
- raise vimconn.vimconnConflictException(request_response.text)
- else:
- raise vimconn.vimconnUnexpectedResponse("VIM HTTP_response {}, {}".format(request_response.status_code, str(request_response.text)))
-
- def new_tenant(self,tenant_name,tenant_description):
- '''Adds a new tenant to VIM with this name and description, returns the tenant identifier'''
- #print "VIMConnector: Adding a new tenant to VIM"
- payload_dict = {"tenant": {"name":tenant_name,"description": tenant_description, "enabled": True}}
- payload_req = json.dumps(payload_dict)
- try:
- url = self.url_admin+'/tenants'
- self.logger.info("Adding a new tenant %s", url)
- vim_response = requests.post(url, headers = self.headers_req, data=payload_req)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- js_v(response, new_tenant_response_schema)
- #r = self._remove_extra_items(response, new_tenant_response_schema)
- #if r is not None:
- # self.logger.warn("Warning: remove extra items %s", str(r))
- tenant_id = response['tenant']['id']
- return tenant_id
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def delete_tenant(self,tenant_id):
- '''Delete a tenant from VIM. Returns the old tenant identifier'''
- try:
- url = self.url_admin+'/tenants/'+tenant_id
- self.logger.info("Delete a tenant DELETE %s", url)
- vim_response = requests.delete(url, headers = self.headers_req)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- return tenant_id
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def get_tenant_list(self, filter_dict={}):
- '''Obtain tenants of VIM
- filter_dict can contain the following keys:
- name: filter by tenant name
- id: filter by tenant uuid/id
- <other VIM specific>
- Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
- '''
- filterquery=[]
- filterquery_text=''
- for k,v in filter_dict.iteritems():
- filterquery.append(str(k)+'='+str(v))
- if len(filterquery)>0:
- filterquery_text='?'+ '&'.join(filterquery)
- try:
- url = self.url+'/tenants'+filterquery_text
- self.logger.info("get_tenant_list GET %s", url)
- vim_response = requests.get(url, headers = self.headers_req)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- return vim_response.json()["tenants"]
- except requests.exceptions.RequestException as e:
- self._format_request_exception(e)
-
- def new_network(self,net_name, net_type, ip_profile=None, shared=False, vlan=None): #, **vim_specific):
- """Adds a tenant network to VIM
- Params:
- 'net_name': name of the network
- 'net_type': one of:
- 'bridge': overlay isolated network
- 'data': underlay E-LAN network for Passthrough and SRIOV interfaces
- 'ptp': underlay E-LINE network for Passthrough and SRIOV interfaces.
- 'ip_profile': is a dict containing the IP parameters of the network
- 'ip_version': can be "IPv4" or "IPv6" (Currently only IPv4 is implemented)
- 'subnet_address': ip_prefix_schema, that is X.X.X.X/Y
- 'gateway_address': (Optional) ip_schema, that is X.X.X.X
- 'dns_address': (Optional) comma separated list of ip_schema, e.g. X.X.X.X[,X,X,X,X]
- 'dhcp_enabled': True or False
- 'dhcp_start_address': ip_schema, first IP to grant
- 'dhcp_count': number of IPs to grant.
- 'shared': if this network can be seen/use by other tenants/organization
- 'vlan': in case of a data or ptp net_type, the intended vlan tag to be used for the network
- Returns a tuple with the network identifier and created_items, or raises an exception on error
- created_items can be None or a dictionary where this method can include key-values that will be passed to
- the method delete_network. Can be used to store created segments, created l2gw connections, etc.
- Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
- as not present.
- """
- try:
- created_items = {}
- self._get_my_tenant()
- if net_type=="bridge":
- net_type="bridge_data"
- payload_req = {"name": net_name, "type": net_type, "tenant_id": self.tenant, "shared": shared}
- if vlan:
- payload_req["provider:vlan"] = vlan
- # payload_req.update(vim_specific)
- url = self.url+'/networks'
- self.logger.info("Adding a new network POST: %s DATA: %s", url, str(payload_req))
- vim_response = requests.post(url, headers = self.headers_req, data=json.dumps({"network": payload_req}) )
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- js_v(response, new_network_response_schema)
- #r = self._remove_extra_items(response, new_network_response_schema)
- #if r is not None:
- # self.logger.warn("Warning: remove extra items %s", str(r))
- network_id = response['network']['id']
- return network_id, created_items
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def get_network_list(self, filter_dict={}):
- '''Obtain tenant networks of VIM
- Filter_dict can be:
- name: network name
- id: network uuid
- public: boolean
- tenant_id: tenant
- admin_state_up: boolean
- status: 'ACTIVE'
- Returns the network list of dictionaries
- '''
- try:
- if 'tenant_id' not in filter_dict:
- filter_dict["tenant_id"] = self._get_my_tenant()
- elif not filter_dict["tenant_id"]:
- del filter_dict["tenant_id"]
- filterquery=[]
- filterquery_text=''
- for k,v in filter_dict.iteritems():
- filterquery.append(str(k)+'='+str(v))
- if len(filterquery)>0:
- filterquery_text='?'+ '&'.join(filterquery)
- url = self.url+'/networks'+filterquery_text
- self.logger.info("Getting network list GET %s", url)
- vim_response = requests.get(url, headers = self.headers_req)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- return response['networks']
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def get_network(self, net_id):
- '''Obtain network details of network id'''
- try:
- url = self.url+'/networks/'+net_id
- self.logger.info("Getting network GET %s", url)
- vim_response = requests.get(url, headers = self.headers_req)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- return response['network']
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def delete_network(self, net_id, created_items=None):
- """
- Removes a tenant network from VIM and its associated elements
- :param net_id: VIM identifier of the network, provided by method new_network
- :param created_items: dictionary with extra items to be deleted. provided by method new_network
- Returns the network identifier or raises an exception upon error or when network is not found
- """
- try:
- self._get_my_tenant()
- url = self.url+'/networks/'+net_id
- self.logger.info("Deleting VIM network DELETE %s", url)
- vim_response = requests.delete(url, headers=self.headers_req)
- self._check_http_request_response(vim_response)
- #self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- return net_id
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def get_flavor(self, flavor_id):
- '''Obtain flavor details from the VIM'''
- try:
- self._get_my_tenant()
- url = self.url+'/'+self.tenant+'/flavors/'+flavor_id
- self.logger.info("Getting flavor GET %s", url)
- vim_response = requests.get(url, headers = self.headers_req)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- js_v(response, get_flavor_response_schema)
- r = self._remove_extra_items(response, get_flavor_response_schema)
- if r is not None:
- self.logger.warn("Warning: remove extra items %s", str(r))
- return response['flavor']
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def new_flavor(self, flavor_data):
- '''Adds a tenant flavor to VIM'''
- '''Returns the flavor identifier'''
- try:
- new_flavor_dict = flavor_data.copy()
- for device in new_flavor_dict.get('extended', {}).get('devices', ()):
- if 'image name' in device:
- del device['image name']
- if 'name' in device:
- del device['name']
- numas = new_flavor_dict.get('extended', {}).get('numas')
- if numas:
- numa = numas[0]
- # translate memory, cpus to EPA
- if "cores" not in numa and "threads" not in numa and "paired-threads" not in numa:
- numa["paired-threads"] = new_flavor_dict["vcpus"]
- if "memory" not in numa:
- numa["memory"] = int(math.ceil(new_flavor_dict["ram"]/1024.0))
- for iface in numa.get("interfaces", ()):
- if not iface.get("bandwidth"):
- iface["bandwidth"] = "1 Mbps"
-
- new_flavor_dict["name"] = flavor_data["name"][:64]
- self._get_my_tenant()
- payload_req = json.dumps({'flavor': new_flavor_dict})
- url = self.url+'/'+self.tenant+'/flavors'
- self.logger.info("Adding a new VIM flavor POST %s", url)
- vim_response = requests.post(url, headers = self.headers_req, data=payload_req)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- js_v(response, new_flavor_response_schema)
- r = self._remove_extra_items(response, new_flavor_response_schema)
- if r is not None:
- self.logger.warn("Warning: remove extra items %s", str(r))
- flavor_id = response['flavor']['id']
- return flavor_id
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def delete_flavor(self,flavor_id):
- '''Deletes a tenant flavor from VIM'''
- '''Returns the old flavor_id'''
- try:
- self._get_my_tenant()
- url = self.url+'/'+self.tenant+'/flavors/'+flavor_id
- self.logger.info("Deleting VIM flavor DELETE %s", url)
- vim_response = requests.delete(url, headers=self.headers_req)
- self._check_http_request_response(vim_response)
- #self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- return flavor_id
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def get_image(self, image_id):
- '''Obtain image details from the VIM'''
- try:
- self._get_my_tenant()
- url = self.url+'/'+self.tenant+'/images/'+image_id
- self.logger.info("Getting image GET %s", url)
- vim_response = requests.get(url, headers = self.headers_req)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- js_v(response, get_image_response_schema)
- r = self._remove_extra_items(response, get_image_response_schema)
- if r is not None:
- self.logger.warn("Warning: remove extra items %s", str(r))
- return response['image']
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def new_image(self,image_dict):
- ''' Adds a tenant image to VIM, returns image_id'''
- try:
- self._get_my_tenant()
- new_image_dict={'name': image_dict['name'][:64]}
- if image_dict.get('description'):
- new_image_dict['description'] = image_dict['description']
- if image_dict.get('metadata'):
- new_image_dict['metadata'] = yaml.load(image_dict['metadata'])
- if image_dict.get('location'):
- new_image_dict['path'] = image_dict['location']
- payload_req = json.dumps({"image":new_image_dict})
- url=self.url + '/' + self.tenant + '/images'
- self.logger.info("Adding a new VIM image POST %s", url)
- vim_response = requests.post(url, headers = self.headers_req, data=payload_req)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- js_v(response, new_image_response_schema)
- r = self._remove_extra_items(response, new_image_response_schema)
- if r is not None:
- self.logger.warn("Warning: remove extra items %s", str(r))
- image_id = response['image']['id']
- return image_id
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def delete_image(self, image_id):
- '''Deletes a tenant image from VIM'''
- '''Returns the deleted image_id'''
- try:
- self._get_my_tenant()
- url = self.url + '/'+ self.tenant +'/images/'+image_id
- self.logger.info("Deleting VIM image DELETE %s", url)
- vim_response = requests.delete(url, headers=self.headers_req)
- self._check_http_request_response(vim_response)
- #self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- return image_id
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def get_image_id_from_path(self, path):
- '''Get the image id from image path in the VIM database. Returns the image_id'''
- try:
- self._get_my_tenant()
- url=self.url + '/' + self.tenant + '/images?path='+quote(path)
- self.logger.info("Getting images GET %s", url)
- vim_response = requests.get(url)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- js_v(response, get_images_response_schema)
- #r = self._remove_extra_items(response, get_images_response_schema)
- #if r is not None:
- # self.logger.warn("Warning: remove extra items %s", str(r))
- if len(response['images'])==0:
- raise vimconn.vimconnNotFoundException("Image not found at VIM with path '%s'", path)
- elif len(response['images'])>1:
- raise vimconn.vimconnConflictException("More than one image found at VIM with path '%s'", path)
- return response['images'][0]['id']
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def get_image_list(self, filter_dict={}):
- '''Obtain tenant images from VIM
- Filter_dict can be:
- name: image name
- id: image uuid
- checksum: image checksum
- location: image path
- Returns the image list of dictionaries:
- [{<the fields at Filter_dict plus some VIM specific>}, ...]
- List can be empty
- '''
- try:
- self._get_my_tenant()
- filterquery=[]
- filterquery_text=''
- for k,v in filter_dict.iteritems():
- filterquery.append(str(k)+'='+str(v))
- if len(filterquery)>0:
- filterquery_text='?'+ '&'.join(filterquery)
- url = self.url+'/'+self.tenant+'/images'+filterquery_text
- self.logger.info("Getting image list GET %s", url)
- vim_response = requests.get(url, headers = self.headers_req)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- return response['images']
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def new_vminstancefromJSON(self, vm_data):
- '''Adds a VM instance to VIM'''
- '''Returns the instance identifier'''
- try:
- self._get_my_tenant()
- except Exception as e:
- return -vimconn.HTTP_Not_Found, str(e)
- print "VIMConnector: Adding a new VM instance from JSON to VIM"
- payload_req = vm_data
- try:
- vim_response = requests.post(self.url+'/'+self.tenant+'/servers', headers = self.headers_req, data=payload_req)
- except requests.exceptions.RequestException as e:
- print "new_vminstancefromJSON Exception: ", e.args
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print vim_response
- #print vim_response.status_code
- if vim_response.status_code == 200:
- #print vim_response.json()
- #print json.dumps(vim_response.json(), indent=4)
- res,http_content = self._format_in(vim_response, new_image_response_schema)
- #print http_content
- if res:
- r = self._remove_extra_items(http_content, new_image_response_schema)
- if r is not None: print "Warning: remove extra items ", r
- #print http_content
- vminstance_id = http_content['server']['id']
- print "Tenant image id: ",vminstance_id
- return vim_response.status_code,vminstance_id
- else: return -vimconn.HTTP_Bad_Request,http_content
- else:
- #print vim_response.text
- jsonerror = self._format_jsonerror(vim_response)
- text = 'Error in VIM "%s": not possible to add new vm instance. HTTP Response: %d. Error: %s' % (self.url, vim_response.status_code, jsonerror)
- #print text
- return -vim_response.status_code,text
-
- def new_vminstance(self, name, description, start, image_id, flavor_id, net_list, cloud_config=None, disk_list=None,
- availability_zone_index=None, availability_zone_list=None):
- """Adds a VM instance to VIM
- Params:
- start: indicates if VM must start or boot in pause mode. Ignored
- image_id,flavor_id: image and flavor uuid
- net_list: list of interfaces, each one is a dictionary with:
- name:
- net_id: network uuid to connect
- vpci: virtual vcpi to assign
- model: interface model, virtio, e1000, ...
- mac_address:
- use: 'data', 'bridge', 'mgmt'
- type: 'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
- vim_id: filled/added by this function
- #TODO ip, security groups
- Returns a tuple with the instance identifier and created_items or raises an exception on error
- created_items can be None or a dictionary where this method can include key-values that will be passed to
- the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
- Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
- as not present.
- """
- self.logger.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'", image_id, flavor_id, str(net_list))
- try:
- self._get_my_tenant()
-# net_list = []
-# for k,v in net_dict.items():
-# print k,v
-# net_list.append('{"name":"' + k + '", "uuid":"' + v + '"}')
-# net_list_string = ', '.join(net_list)
- virtio_net_list=[]
- for net in net_list:
- if not net.get("net_id"):
- continue
- net_dict = {'uuid': net["net_id"]}
- if net.get("type"):
- if net["type"] == "SR-IOV":
- net_dict["type"] = "VF"
- elif net["type"] == "PCI-PASSTHROUGH":
- net_dict["type"] = "PF"
- else:
- net_dict["type"] = net["type"]
- if net.get("name"):
- net_dict["name"] = net["name"]
- if net.get("vpci"):
- net_dict["vpci"] = net["vpci"]
- if net.get("model"):
- if net["model"] == "VIRTIO" or net["model"] == "paravirt":
- net_dict["model"] = "virtio"
- else:
- net_dict["model"] = net["model"]
- if net.get("mac_address"):
- net_dict["mac_address"] = net["mac_address"]
- if net.get("ip_address"):
- net_dict["ip_address"] = net["ip_address"]
- virtio_net_list.append(net_dict)
- payload_dict={ "name": name[:64],
- "description": description,
- "imageRef": image_id,
- "flavorRef": flavor_id,
- "networks": virtio_net_list
- }
- if start != None:
- payload_dict["start"] = start
- payload_req = json.dumps({"server": payload_dict})
- url = self.url+'/'+self.tenant+'/servers'
- self.logger.info("Adding a new vm POST %s DATA %s", url, payload_req)
- vim_response = requests.post(url, headers = self.headers_req, data=payload_req)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- js_v(response, new_vminstance_response_schema)
- #r = self._remove_extra_items(response, new_vminstance_response_schema)
- #if r is not None:
- # self.logger.warn("Warning: remove extra items %s", str(r))
- vminstance_id = response['server']['id']
-
- #connect data plane interfaces to network
- for net in net_list:
- if net["type"]=="virtual":
- if not net.get("net_id"):
- continue
- for iface in response['server']['networks']:
- if "name" in net:
- if net["name"]==iface["name"]:
- net["vim_id"] = iface['iface_id']
- break
- elif "net_id" in net:
- if net["net_id"]==iface["net_id"]:
- net["vim_id"] = iface['iface_id']
- break
- else: #dataplane
- for numa in response['server'].get('extended',{}).get('numas',() ):
- for iface in numa.get('interfaces',() ):
- if net['name'] == iface['name']:
- net['vim_id'] = iface['iface_id']
- #Code bellow is not needed, current openvim connect dataplane interfaces
- #if net.get("net_id"):
- ##connect dataplane interface
- # result, port_id = self.connect_port_network(iface['iface_id'], net["net_id"])
- # if result < 0:
- # error_text = "Error attaching port %s to network %s: %s." % (iface['iface_id'], net["net_id"], port_id)
- # print "new_vminstance: " + error_text
- # self.delete_vminstance(vminstance_id)
- # return result, error_text
- break
-
- return vminstance_id, None
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def get_vminstance(self, vm_id):
- '''Returns the VM instance information from VIM'''
- try:
- self._get_my_tenant()
- url = self.url+'/'+self.tenant+'/servers/'+vm_id
- self.logger.info("Getting vm GET %s", url)
- vim_response = requests.get(url, headers = self.headers_req)
- vim_response = requests.get(url, headers = self.headers_req)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- js_v(response, new_vminstance_response_schema)
- #r = self._remove_extra_items(response, new_vminstance_response_schema)
- #if r is not None:
- # self.logger.warn("Warning: remove extra items %s", str(r))
- return response['server']
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def delete_vminstance(self, vm_id, created_items=None):
- '''Removes a VM instance from VIM, returns the deleted vm_id'''
- try:
- self._get_my_tenant()
- url = self.url+'/'+self.tenant+'/servers/'+vm_id
- self.logger.info("Deleting VIM vm DELETE %s", url)
- vim_response = requests.delete(url, headers=self.headers_req)
- self._check_http_request_response(vim_response)
- #self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- return vm_id
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def refresh_vms_status(self, vm_list):
- '''Refreshes the status of the virtual machines'''
- try:
- self._get_my_tenant()
- except requests.exceptions.RequestException as e:
- self._format_request_exception(e)
- vm_dict={}
- for vm_id in vm_list:
- vm={}
- #print "VIMConnector refresh_tenant_vms and nets: Getting tenant VM instance information from VIM"
- try:
- url = self.url + '/' + self.tenant + '/servers/' + vm_id
- self.logger.info("Getting vm GET %s", url)
- vim_response = requests.get(url, headers = self.headers_req)
- self._check_http_request_response(vim_response)
- response = vim_response.json()
- js_v(response, new_vminstance_response_schema)
- if response['server']['status'] in vmStatus2manoFormat:
- vm['status'] = vmStatus2manoFormat[ response['server']['status'] ]
- else:
- vm['status'] = "OTHER"
- vm['error_msg'] = "VIM status reported " + response['server']['status']
- if response['server'].get('last_error'):
- vm['error_msg'] = response['server']['last_error']
- vm["vim_info"] = yaml.safe_dump(response['server'])
- #get interfaces info
- try:
- management_ip = False
- url2 = self.url + '/ports?device_id=' + quote(vm_id)
- self.logger.info("Getting PORTS GET %s", url2)
- vim_response2 = requests.get(url2, headers = self.headers_req)
- self._check_http_request_response(vim_response2)
- client_data = vim_response2.json()
- if isinstance(client_data.get("ports"), list):
- vm["interfaces"]=[]
- for port in client_data.get("ports"):
- interface={}
- interface['vim_info'] = yaml.safe_dump(port)
- interface["mac_address"] = port.get("mac_address")
- interface["vim_net_id"] = port.get("network_id")
- interface["vim_interface_id"] = port["id"]
- interface["ip_address"] = port.get("ip_address")
- if interface["ip_address"]:
- management_ip = True
- if interface["ip_address"] == "0.0.0.0":
- interface["ip_address"] = None
- vm["interfaces"].append(interface)
-
- except Exception as e:
- self.logger.error("refresh_vms_and_nets. Port get %s: %s", type(e).__name__, str(e))
-
- if vm['status'] == "ACTIVE" and not management_ip:
- vm['status'] = "ACTIVE:NoMgmtIP"
-
- except vimconn.vimconnNotFoundException as e:
- self.logger.error("Exception getting vm status: %s", str(e))
- vm['status'] = "DELETED"
- vm['error_msg'] = str(e)
- except (requests.exceptions.RequestException, js_e.ValidationError, vimconn.vimconnException) as e:
- self.logger.error("Exception getting vm status: %s", str(e))
- vm['status'] = "VIM_ERROR"
- vm['error_msg'] = str(e)
- vm_dict[vm_id] = vm
- return vm_dict
-
- def refresh_nets_status(self, net_list):
- '''Get the status of the networks
- Params: the list of network identifiers
- Returns a dictionary with:
- net_id: #VIM id of this network
- status: #Mandatory. Text with one of:
- # DELETED (not found at vim)
- # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
- # OTHER (Vim reported other status not understood)
- # ERROR (VIM indicates an ERROR status)
- # ACTIVE, INACTIVE, DOWN (admin down),
- # BUILD (on building process)
- #
- error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
- vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
-
- '''
- try:
- self._get_my_tenant()
- except requests.exceptions.RequestException as e:
- self._format_request_exception(e)
-
- net_dict={}
- for net_id in net_list:
- net = {}
- #print "VIMConnector refresh_tenant_vms_and_nets: Getting tenant network from VIM (tenant: " + str(self.tenant) + "): "
- try:
- net_vim = self.get_network(net_id)
- if net_vim['status'] in netStatus2manoFormat:
- net["status"] = netStatus2manoFormat[ net_vim['status'] ]
- else:
- net["status"] = "OTHER"
- net["error_msg"] = "VIM status reported " + net_vim['status']
-
- if net["status"] == "ACTIVE" and not net_vim['admin_state_up']:
- net["status"] = "DOWN"
- if net_vim.get('last_error'):
- net['error_msg'] = net_vim['last_error']
- net["vim_info"] = yaml.safe_dump(net_vim)
- except vimconn.vimconnNotFoundException as e:
- self.logger.error("Exception getting net status: %s", str(e))
- net['status'] = "DELETED"
- net['error_msg'] = str(e)
- except (requests.exceptions.RequestException, js_e.ValidationError, vimconn.vimconnException) as e:
- self.logger.error("Exception getting net status: %s", str(e))
- net['status'] = "VIM_ERROR"
- net['error_msg'] = str(e)
- net_dict[net_id] = net
- return net_dict
-
- def action_vminstance(self, vm_id, action_dict, created_items={}):
- '''Send and action over a VM instance from VIM'''
- '''Returns the status'''
- try:
- self._get_my_tenant()
- if "console" in action_dict:
- raise vimconn.vimconnException("getting console is not available at openvim", http_code=vimconn.HTTP_Service_Unavailable)
- url = self.url+'/'+self.tenant+'/servers/'+vm_id+"/action"
- self.logger.info("Action over VM instance POST %s", url)
- vim_response = requests.post(url, headers = self.headers_req, data=json.dumps(action_dict) )
- self._check_http_request_response(vim_response)
- return None
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
-#NOT USED METHODS in current version
-
- def host_vim2gui(self, host, server_dict):
- '''Transform host dictionary from VIM format to GUI format,
- and append to the server_dict
- '''
- if type(server_dict) is not dict:
- print 'vimconnector.host_vim2gui() ERROR, param server_dict must be a dictionary'
- return
- RAD={}
- occupation={}
- for numa in host['host']['numas']:
- RAD_item={}
- occupation_item={}
- #memory
- RAD_item['memory']={'size': str(numa['memory'])+'GB', 'eligible': str(numa['hugepages'])+'GB'}
- occupation_item['memory']= str(numa['hugepages_consumed'])+'GB'
- #cpus
- RAD_item['cpus']={}
- RAD_item['cpus']['cores'] = []
- RAD_item['cpus']['eligible_cores'] = []
- occupation_item['cores']=[]
- for _ in range(0, len(numa['cores']) / 2):
- RAD_item['cpus']['cores'].append( [] )
- for core in numa['cores']:
- RAD_item['cpus']['cores'][core['core_id']].append(core['thread_id'])
- if not 'status' in core: RAD_item['cpus']['eligible_cores'].append(core['thread_id'])
- if 'instance_id' in core: occupation_item['cores'].append(core['thread_id'])
- #ports
- RAD_item['ports']={}
- occupation_item['ports']={}
- for iface in numa['interfaces']:
- RAD_item['ports'][ iface['pci'] ] = 'speed:'+str(iface['Mbps'])+'M'
- occupation_item['ports'][ iface['pci'] ] = { 'occupied': str(100*iface['Mbps_consumed'] / iface['Mbps']) + "%" }
-
- RAD[ numa['numa_socket'] ] = RAD_item
- occupation[ numa['numa_socket'] ] = occupation_item
- server_dict[ host['host']['name'] ] = {'RAD':RAD, 'occupation':occupation}
-
- def get_hosts_info(self):
- '''Get the information of deployed hosts
- Returns the hosts content'''
- #obtain hosts list
- url=self.url+'/hosts'
- try:
- vim_response = requests.get(url)
- except requests.exceptions.RequestException as e:
- print "get_hosts_info Exception: ", e.args
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print "vim get", url, "response:", vim_response.status_code, vim_response.json()
- #print vim_response.status_code
- #print json.dumps(vim_response.json(), indent=4)
- if vim_response.status_code != 200:
- #TODO: get error
- print 'vimconnector.get_hosts_info error getting host list %d %s' %(vim_response.status_code, vim_response.json())
- return -vim_response.status_code, "Error getting host list"
-
- res,hosts = self._format_in(vim_response, get_hosts_response_schema)
-
- if res==False:
- print "vimconnector.get_hosts_info error parsing GET HOSTS vim response", hosts
- return vimconn.HTTP_Internal_Server_Error, hosts
- #obtain hosts details
- hosts_dict={}
- for host in hosts['hosts']:
- url=self.url+'/hosts/'+host['id']
- try:
- vim_response = requests.get(url)
- except requests.exceptions.RequestException as e:
- print "get_hosts_info Exception: ", e.args
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print "vim get", url, "response:", vim_response.status_code, vim_response.json()
- if vim_response.status_code != 200:
- print 'vimconnector.get_hosts_info error getting detailed host %d %s' %(vim_response.status_code, vim_response.json())
- continue
- res,host_detail = self._format_in(vim_response, get_host_detail_response_schema)
- if res==False:
- print "vimconnector.get_hosts_info error parsing GET HOSTS/%s vim response" % host['id'], host_detail
- continue
- #print 'host id '+host['id'], json.dumps(host_detail, indent=4)
- self.host_vim2gui(host_detail, hosts_dict)
- return 200, hosts_dict
-
- def get_hosts(self, vim_tenant):
- '''Get the hosts and deployed instances
- Returns the hosts content'''
- #obtain hosts list
- url=self.url+'/hosts'
- try:
- vim_response = requests.get(url)
- except requests.exceptions.RequestException as e:
- print "get_hosts Exception: ", e.args
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print "vim get", url, "response:", vim_response.status_code, vim_response.json()
- #print vim_response.status_code
- #print json.dumps(vim_response.json(), indent=4)
- if vim_response.status_code != 200:
- #TODO: get error
- print 'vimconnector.get_hosts error getting host list %d %s' %(vim_response.status_code, vim_response.json())
- return -vim_response.status_code, "Error getting host list"
-
- res,hosts = self._format_in(vim_response, get_hosts_response_schema)
-
- if res==False:
- print "vimconnector.get_host error parsing GET HOSTS vim response", hosts
- return vimconn.HTTP_Internal_Server_Error, hosts
- #obtain instances from hosts
- for host in hosts['hosts']:
- url=self.url+'/' + vim_tenant + '/servers?hostId='+host['id']
- try:
- vim_response = requests.get(url)
- except requests.exceptions.RequestException as e:
- print "get_hosts Exception: ", e.args
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print "vim get", url, "response:", vim_response.status_code, vim_response.json()
- if vim_response.status_code != 200:
- print 'vimconnector.get_hosts error getting instances at host %d %s' %(vim_response.status_code, vim_response.json())
- continue
- res,servers = self._format_in(vim_response, get_server_response_schema)
- if res==False:
- print "vimconnector.get_host error parsing GET SERVERS/%s vim response" % host['id'], servers
- continue
- #print 'host id '+host['id'], json.dumps(host_detail, indent=4)
- host['instances'] = servers['servers']
- return 200, hosts['hosts']
-
- def get_processor_rankings(self):
- '''Get the processor rankings in the VIM database'''
- url=self.url+'/processor_ranking'
- try:
- vim_response = requests.get(url)
- except requests.exceptions.RequestException as e:
- print "get_processor_rankings Exception: ", e.args
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print "vim get", url, "response:", vim_response.status_code, vim_response.json()
- #print vim_response.status_code
- #print json.dumps(vim_response.json(), indent=4)
- if vim_response.status_code != 200:
- #TODO: get error
- print 'vimconnector.get_processor_rankings error getting processor rankings %d %s' %(vim_response.status_code, vim_response.json())
- return -vim_response.status_code, "Error getting processor rankings"
-
- res,rankings = self._format_in(vim_response, get_processor_rankings_response_schema)
- return res, rankings['rankings']
-
- def new_host(self, host_data):
- '''Adds a new host to VIM'''
- '''Returns status code of the VIM response'''
- payload_req = host_data
- try:
- url = self.url_admin+'/hosts'
- self.logger.info("Adding a new host POST %s", url)
- vim_response = requests.post(url, headers = self.headers_req, data=payload_req)
- self._check_http_request_response(vim_response)
- self.logger.debug(vim_response.text)
- #print json.dumps(vim_response.json(), indent=4)
- response = vim_response.json()
- js_v(response, new_host_response_schema)
- r = self._remove_extra_items(response, new_host_response_schema)
- if r is not None:
- self.logger.warn("Warning: remove extra items %s", str(r))
- host_id = response['host']['id']
- return host_id
- except (requests.exceptions.RequestException, js_e.ValidationError) as e:
- self._format_request_exception(e)
-
- def new_external_port(self, port_data):
- '''Adds a external port to VIM'''
- '''Returns the port identifier'''
- #TODO change to logging exception code policies
- print "VIMConnector: Adding a new external port"
- payload_req = port_data
- try:
- vim_response = requests.post(self.url_admin+'/ports', headers = self.headers_req, data=payload_req)
- except requests.exceptions.RequestException as e:
- self.logger.error("new_external_port Exception: ", str(e))
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print vim_response
- #print vim_response.status_code
- if vim_response.status_code == 200:
- #print vim_response.json()
- #print json.dumps(vim_response.json(), indent=4)
- res, http_content = self._format_in(vim_response, new_port_response_schema)
- #print http_content
- if res:
- r = self._remove_extra_items(http_content, new_port_response_schema)
- if r is not None: print "Warning: remove extra items ", r
- #print http_content
- port_id = http_content['port']['id']
- print "Port id: ",port_id
- return vim_response.status_code,port_id
- else: return -vimconn.HTTP_Bad_Request,http_content
- else:
- #print vim_response.text
- jsonerror = self._format_jsonerror(vim_response)
- text = 'Error in VIM "%s": not possible to add new external port. HTTP Response: %d. Error: %s' % (self.url_admin, vim_response.status_code, jsonerror)
- #print text
- return -vim_response.status_code,text
-
- def new_external_network(self,net_name,net_type):
- '''Adds a external network to VIM (shared)'''
- '''Returns the network identifier'''
- #TODO change to logging exception code policies
- print "VIMConnector: Adding external shared network to VIM (type " + net_type + "): "+ net_name
-
- payload_req = '{"network":{"name": "' + net_name + '","shared":true,"type": "' + net_type + '"}}'
- try:
- vim_response = requests.post(self.url+'/networks', headers = self.headers_req, data=payload_req)
- except requests.exceptions.RequestException as e:
- self.logger.error( "new_external_network Exception: ", e.args)
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print vim_response
- #print vim_response.status_code
- if vim_response.status_code == 200:
- #print vim_response.json()
- #print json.dumps(vim_response.json(), indent=4)
- res,http_content = self._format_in(vim_response, new_network_response_schema)
- #print http_content
- if res:
- r = self._remove_extra_items(http_content, new_network_response_schema)
- if r is not None: print "Warning: remove extra items ", r
- #print http_content
- network_id = http_content['network']['id']
- print "Network id: ",network_id
- return vim_response.status_code,network_id
- else: return -vimconn.HTTP_Bad_Request,http_content
- else:
- #print vim_response.text
- jsonerror = self._format_jsonerror(vim_response)
- text = 'Error in VIM "%s": not possible to add new external network. HTTP Response: %d. Error: %s' % (self.url, vim_response.status_code, jsonerror)
- #print text
- return -vim_response.status_code,text
-
- def connect_port_network(self, port_id, network_id, admin=False):
- '''Connects a external port to a network'''
- '''Returns status code of the VIM response'''
- #TODO change to logging exception code policies
- print "VIMConnector: Connecting external port to network"
-
- payload_req = '{"port":{"network_id":"' + network_id + '"}}'
- if admin:
- if self.url_admin==None:
- return -vimconn.HTTP_Unauthorized, "datacenter cannot contain admin URL"
- url= self.url_admin
- else:
- url= self.url
- try:
- vim_response = requests.put(url +'/ports/'+port_id, headers = self.headers_req, data=payload_req)
- except requests.exceptions.RequestException as e:
- print "connect_port_network Exception: ", e.args
- return -vimconn.HTTP_Not_Found, str(e.args[0])
- print vim_response
- #print vim_response.status_code
- if vim_response.status_code == 200:
- #print vim_response.json()
- #print json.dumps(vim_response.json(), indent=4)
- res,http_content = self._format_in(vim_response, new_port_response_schema)
- #print http_content
- if res:
- r = self._remove_extra_items(http_content, new_port_response_schema)
- if r is not None: print "Warning: remove extra items ", r
- #print http_content
- port_id = http_content['port']['id']
- print "Port id: ",port_id
- return vim_response.status_code,port_id
- else: return -vimconn.HTTP_Bad_Request,http_content
- else:
- print vim_response.text
- jsonerror = self._format_jsonerror(vim_response)
- text = 'Error in VIM "%s": not possible to connect external port to network. HTTP Response: %d. Error: %s' % (self.url_admin, vim_response.status_code, jsonerror)
- print text
- return -vim_response.status_code,text
-
-
projects / osm / RO.git / blobdiff