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
-
+try:
+ from urllib import quote # Python 2.X
+except ImportError:
+ from urllib.parse import quote # Python 3+
+
'''contain the openvim virtual machine status to openmano status'''
vmStatus2manoFormat={'ACTIVE':'ACTIVE',
'PAUSED':'PAUSED',
self.tenant = tenant_id
def __setitem__(self,index, value):
- '''Set individuals parameters
+ '''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)
+ vimconn.vimconnector.__setitem__(self,index, value)
def _get_my_tenant(self):
'''Obtain uuid of my tenant from name
try:
client_data = http_response.json()
js_v(client_data, schema)
- #print "Input data: ", str(client_data)
+ #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
+ 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:
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))
+ 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.vimconnNotFoundException(request_response.text)
elif request_response.status_code == vimconn.HTTP_Conflict:
raise vimconn.vimconnConflictException(request_response.text)
- else:
+ 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"
+ #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:
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)
+ #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:
+ #if r is not None:
# self.logger.warn("Warning: remove extra items %s", str(r))
tenant_id = response['tenant']['id']
return tenant_id
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)
+ #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)
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)
+ #print(json.dumps(vim_response.json(), indent=4))
return vim_response.json()["tenants"]
except requests.exceptions.RequestException as e:
self._format_request_exception(e)
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)
+ #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:
+ #if r is not None:
# self.logger.warn("Warning: remove extra items %s", str(r))
network_id = response['network']['id']
return network_id
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:
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)
+ #print(json.dumps(vim_response.json(), indent=4))
response = vim_response.json()
return response['networks']
except (requests.exceptions.RequestException, js_e.ValidationError) as e:
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)
+ #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):
'''Deletes a tenant network from VIM'''
'''Returns the network identifier'''
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)
+ #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)
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)
+ #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:
+ 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']
new_flavor_dict["name"] = flavor_data["name"][:64]
self._get_my_tenant()
payload_req = json.dumps({'flavor': new_flavor_dict})
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)
+ #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:
+ if r is not None:
self.logger.warn("Warning: remove extra items %s", str(r))
flavor_id = response['flavor']['id']
return flavor_id
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)
+ #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)
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)
+ #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:
+ 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:
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)
+ #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:
+ 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'''
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)
+ #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:
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)
+ #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:
+ #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)
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)
+ #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._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"
+ 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
+ print("new_vminstancefromJSON Exception: ", e.args)
return -vimconn.HTTP_Not_Found, str(e.args[0])
- print vim_response
- #print vim_response.status_code
+ 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)
+ #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
+ #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
+ 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
+ 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
+ #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
+ #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):
+ 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
net_id: network uuid to connect
vpci: virtual vcpi to assign
model: interface model, virtio, e2000, ...
- mac_address:
+ mac_address:
use: 'data', 'bridge', 'mgmt'
type: 'virtual', 'PF', 'VF', 'VFnotShared'
vim_id: filled/added by this function
self._get_my_tenant()
# net_list = []
# for k,v in net_dict.items():
-# print k,v
+# print(k,v)
# net_list.append('{"name":"' + k + '", "uuid":"' + v + '"}')
-# net_list_string = ', '.join(net_list)
+# net_list_string = ', '.join(net_list)
virtio_net_list=[]
for net in net_list:
if not net.get("net_id"):
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)
+ #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:
+ #if r is not None:
# self.logger.warn("Warning: remove extra items %s", str(r))
vminstance_id = response['server']['id']
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
+ #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
+ # print("new_vminstance: " + error_text)
# self.delete_vminstance(vminstance_id)
# return result, error_text
break
-
+
return vminstance_id
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:
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)
+ #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:
+ #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):
'''Removes a VM instance from VIM, returns the deleted vm_id'''
try:
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)
+ #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)
vm_dict={}
for vm_id in vm_list:
vm={}
- #print "VIMConnector refresh_tenant_vms and nets: Getting tenant VM instance information from VIM"
+ #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)
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"
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, ...)
+ # 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),
+ # ACTIVE, INACTIVE, DOWN (admin down),
# BUILD (on building process)
#
- error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
+ 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)
'''
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) + "): "
+ #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:
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'] = str(e)
net_dict[net_id] = net
return net_dict
-
+
def action_vminstance(self, vm_id, action_dict):
'''Send and action over a VM instance from VIM'''
'''Returns the status'''
except (requests.exceptions.RequestException, js_e.ValidationError) as e:
self._format_request_exception(e)
-#NOT USED METHODS in current version
-
+#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'
+ if type(server_dict) is not dict:
+ print('vimconnector.host_vim2gui() ERROR, param server_dict must be a dictionary')
return
RAD={}
occupation={}
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}
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
- print "get_hosts_info Exception: ", e.args
+ 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)
+ 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())
+ 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
+ print("vimconnector.get_hosts_info error parsing GET HOSTS vim response", hosts)
return vimconn.HTTP_Internal_Server_Error, hosts
#obtain hosts details
hosts_dict={}
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
- print "get_hosts_info Exception: ", e.args
+ 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 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())
+ 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
+ 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)
+ #print('host id '+host['id'], json.dumps(host_detail, indent=4))
self.host_vim2gui(host_detail, hosts_dict)
return 200, hosts_dict
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
- print "get_hosts Exception: ", e.args
+ 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)
+ 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())
+ 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
+ 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']:
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
- print "get_hosts Exception: ", e.args
+ 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 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())
+ 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
+ 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)
+ #print('host id '+host['id'], json.dumps(host_detail, indent=4))
host['instances'] = servers['servers']
return 200, hosts['hosts']
try:
vim_response = requests.get(url)
except requests.exceptions.RequestException as e:
- print "get_processor_rankings Exception: ", e.args
+ 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)
+ 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())
+ 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'''
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)
+ #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:
+ 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"
+ 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
+ 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)
+ #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
+ #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
+ 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
+ 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
+ #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
+ #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
-
+ 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
+ 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)
+ #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
+ #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
+ 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
+ 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
+ #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
+ #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"
-
+ print("VIMConnector: Connecting external port to network")
+
payload_req = '{"port":{"network_id":"' + network_id + '"}}'
if admin:
if self.url_admin==None:
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
+ print("connect_port_network Exception: ", e.args)
return -vimconn.HTTP_Not_Found, str(e.args[0])
- print vim_response
- #print vim_response.status_code
+ 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)
+ #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
+ #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
+ 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
+ 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
+ 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
+ print(text)
return -vim_response.status_code,text
-
-
projects / osm / RO.git / blobdiff