vimconn_openstack.py

   1 # -*- coding: utf-8 -*-
   2
   3 ##
   4 # Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
   5 # This file is part of openmano
   6 # All Rights Reserved.
   7 #
   8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   9 # not use this file except in compliance with the License. You may obtain
  10 # a copy of the License at
  11 #
  12 #         http://www.apache.org/licenses/LICENSE-2.0
  13 #
  14 # Unless required by applicable law or agreed to in writing, software
  15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  17 # License for the specific language governing permissions and limitations
  18 # under the License.
  19 #
  20 # For those usages not covered by the Apache License, Version 2.0 please
  21 # contact with: nfvlabs@tid.es
  22 ##
  23
  24 '''
  25 osconnector implements all the methods to interact with openstack using the python-client.
  26 '''
  27 __author__="Alfonso Tierno, Gerardo Garcia"
  28 __date__ ="$22-jun-2014 11:19:29$"
  29
  30 import vimconn
  31 import json
  32 import yaml
  33 import logging
  34 import netaddr
  35
  36 from novaclient import client as nClient, exceptions as nvExceptions
  37 import keystoneclient.v2_0.client as ksClient
  38 import keystoneclient.exceptions as ksExceptions
  39 import glanceclient.v2.client as glClient
  40 import glanceclient.client as gl1Client
  41 import glanceclient.exc as gl1Exceptions
  42 from httplib import HTTPException
  43 from neutronclient.neutron import client as neClient
  44 from neutronclient.common import exceptions as neExceptions
  45 from requests.exceptions import ConnectionError
  46
  47 '''contain the openstack virtual machine status to openmano status'''
  48 vmStatus2manoFormat={'ACTIVE':'ACTIVE',
  49                      'PAUSED':'PAUSED',
  50                      'SUSPENDED': 'SUSPENDED',
  51                      'SHUTOFF':'INACTIVE',
  52                      'BUILD':'BUILD',
  53                      'ERROR':'ERROR','DELETED':'DELETED'
  54                      }
  55 netStatus2manoFormat={'ACTIVE':'ACTIVE','PAUSED':'PAUSED','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED'
  56                      }
  57
  58 class vimconnector(vimconn.vimconnector):
  59     def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None, log_level="DEBUG", config={}):
  60         '''using common constructor parameters. In this case
  61         'url' is the keystone authorization url,
  62         'url_admin' is not use
  63         '''
  64         vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level, config)
  65
  66         self.k_creds={}
  67         self.n_creds={}
  68         if not url:
  69             raise TypeError, 'url param can not be NoneType'
  70         self.k_creds['auth_url'] = url
  71         self.n_creds['auth_url'] = url
  72         if tenant_name:
  73             self.k_creds['tenant_name'] = tenant_name
  74             self.n_creds['project_id']  = tenant_name
  75         if tenant_id:
  76             self.k_creds['tenant_id'] = tenant_id
  77             self.n_creds['tenant_id']  = tenant_id
  78         if user:
  79             self.k_creds['username'] = user
  80             self.n_creds['username'] = user
  81         if passwd:
  82             self.k_creds['password'] = passwd
  83             self.n_creds['api_key']  = passwd
  84         self.reload_client       = True
  85         self.logger = logging.getLogger('openmano.vim.openstack')
  86
  87     def __setitem__(self,index, value):
  88         '''Set individuals parameters
  89         Throw TypeError, KeyError
  90         '''
  91         if index=='tenant_id':
  92             self.reload_client=True
  93             self.tenant_id = value
  94             if value:
  95                 self.k_creds['tenant_id'] = value
  96                 self.n_creds['tenant_id']  = value
  97             else:
  98                 del self.k_creds['tenant_name']
  99                 del self.n_creds['project_id']
 100         elif index=='tenant_name':
 101             self.reload_client=True
 102             self.tenant_name = value
 103             if value:
 104                 self.k_creds['tenant_name'] = value
 105                 self.n_creds['project_id']  = value
 106             else:
 107                 del self.k_creds['tenant_name']
 108                 del self.n_creds['project_id']
 109         elif index=='user':
 110             self.reload_client=True
 111             self.user = value
 112             if value:
 113                 self.k_creds['username'] = value
 114                 self.n_creds['username'] = value
 115             else:
 116                 del self.k_creds['username']
 117                 del self.n_creds['username']
 118         elif index=='passwd':
 119             self.reload_client=True
 120             self.passwd = value
 121             if value:
 122                 self.k_creds['password'] = value
 123                 self.n_creds['api_key']  = value
 124             else:
 125                 del self.k_creds['password']
 126                 del self.n_creds['api_key']
 127         elif index=='url':
 128             self.reload_client=True
 129             self.url = value
 130             if value:
 131                 self.k_creds['auth_url'] = value
 132                 self.n_creds['auth_url'] = value
 133             else:
 134                 raise TypeError, 'url param can not be NoneType'
 135         else:
 136             vimconn.vimconnector.__setitem__(self,index, value)
 137
 138     def _reload_connection(self):
 139         '''Called before any operation, it check if credentials has changed
 140         Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
 141         '''
 142         #TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
 143         if self.reload_client:
 144             #test valid params
 145             if len(self.n_creds) <4:
 146                 raise ksExceptions.ClientException("Not enough parameters to connect to openstack")
 147             self.nova = nClient.Client(2, **self.n_creds)
 148             self.keystone = ksClient.Client(**self.k_creds)
 149             self.glance_endpoint = self.keystone.service_catalog.url_for(service_type='image', endpoint_type='publicURL')
 150             self.glance = glClient.Client(self.glance_endpoint, token=self.keystone.auth_token, **self.k_creds)  #TODO check k_creds vs n_creds
 151             self.ne_endpoint=self.keystone.service_catalog.url_for(service_type='network', endpoint_type='publicURL')
 152             self.neutron = neClient.Client('2.0', endpoint_url=self.ne_endpoint, token=self.keystone.auth_token, **self.k_creds)
 153             self.reload_client = False
 154
 155     def __net_os2mano(self, net_list_dict):
 156         '''Transform the net openstack format to mano format
 157         net_list_dict can be a list of dict or a single dict'''
 158         if type(net_list_dict) is dict:
 159             net_list_=(net_list_dict,)
 160         elif type(net_list_dict) is list:
 161             net_list_=net_list_dict
 162         else:
 163             raise TypeError("param net_list_dict must be a list or a dictionary")
 164         for net in net_list_:
 165             if net.get('provider:network_type') == "vlan":
 166                 net['type']='data'
 167             else:
 168                 net['type']='bridge'
 169
 170
 171
 172     def _format_exception(self, exception):
 173         '''Transform a keystone, nova, neutron  exception into a vimconn exception'''
 174         if isinstance(exception, (HTTPException, gl1Exceptions.HTTPException, gl1Exceptions.CommunicationError,
 175                                   ConnectionError, ksExceptions.ConnectionError, neExceptions.ConnectionFailed
 176                                   )):
 177             raise vimconn.vimconnConnectionException(type(exception).__name__ + ": " + str(exception))
 178         elif isinstance(exception, (nvExceptions.ClientException, ksExceptions.ClientException,
 179                                     neExceptions.NeutronException, nvExceptions.BadRequest)):
 180             raise vimconn.vimconnUnexpectedResponse(type(exception).__name__ + ": " + str(exception))
 181         elif isinstance(exception, (neExceptions.NetworkNotFoundClient, nvExceptions.NotFound)):
 182             raise vimconn.vimconnNotFoundException(type(exception).__name__ + ": " + str(exception))
 183         elif isinstance(exception, nvExceptions.Conflict):
 184             raise vimconn.vimconnConflictException(type(exception).__name__ + ": " + str(exception))
 185         else: # ()
 186             raise vimconn.vimconnConnectionException(type(exception).__name__ + ": " + str(exception))
 187
 188     def get_tenant_list(self, filter_dict={}):
 189         '''Obtain tenants of VIM
 190         filter_dict can contain the following keys:
 191             name: filter by tenant name
 192             id: filter by tenant uuid/id
 193             <other VIM specific>
 194         Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
 195         '''
 196         self.logger.debug("Getting tenant from VIM filter: '%s'", str(filter_dict))
 197         try:
 198             self._reload_connection()
 199             tenant_class_list=self.keystone.tenants.findall(**filter_dict)
 200             tenant_list=[]
 201             for tenant in tenant_class_list:
 202                 tenant_list.append(tenant.to_dict())
 203             return tenant_list
 204         except (ksExceptions.ConnectionError, ksExceptions.ClientException, ConnectionError)  as e:
 205             self._format_exception(e)
 206
 207     def new_tenant(self, tenant_name, tenant_description):
 208         '''Adds a new tenant to openstack VIM. Returns the tenant identifier'''
 209         self.logger.debug("Adding a new tenant name: %s", tenant_name)
 210         try:
 211             self._reload_connection()
 212             tenant=self.keystone.tenants.create(tenant_name, tenant_description)
 213             return tenant.id
 214         except (ksExceptions.ConnectionError, ksExceptions.ClientException, ConnectionError)  as e:
 215             self._format_exception(e)
 216
 217     def delete_tenant(self, tenant_id):
 218         '''Delete a tenant from openstack VIM. Returns the old tenant identifier'''
 219         self.logger.debug("Deleting tenant %s from VIM", tenant_id)
 220         try:
 221             self._reload_connection()
 222             self.keystone.tenants.delete(tenant_id)
 223             return tenant_id
 224         except (ksExceptions.ConnectionError, ksExceptions.ClientException, ConnectionError)  as e:
 225             self._format_exception(e)
 226
 227     def new_network(self,net_name, net_type, ip_profile=None, shared=False, vlan=None):
 228         '''Adds a tenant network to VIM. Returns the network identifier'''
 229         self.logger.debug("Adding a new network to VIM name '%s', type '%s'", net_name, net_type)
 230         try:
 231             self._reload_connection()
 232             network_dict = {'name': net_name, 'admin_state_up': True}
 233             if net_type=="data" or net_type=="ptp":
 234                 if self.config.get('dataplane_physical_net') == None:
 235                     raise vimconn.vimconnConflictException("You must provide a 'dataplane_physical_net' at config value before creating sriov network")
 236                 network_dict["provider:physical_network"] = self.config['dataplane_physical_net'] #"physnet_sriov" #TODO physical
 237                 network_dict["provider:network_type"]     = "vlan"
 238                 if vlan!=None:
 239                     network_dict["provider:network_type"] = vlan
 240             network_dict["shared"]=shared
 241             new_net=self.neutron.create_network({'network':network_dict})
 242             #print new_net
 243             #create subnetwork, even if there is no profile
 244             if not ip_profile:
 245                 ip_profile = {}
 246             if 'subnet_address' not in ip_profile:
 247                 #Fake subnet is required
 248                 ip_profile['subnet_address'] = "192.168.111.0/24"
 249             if 'ip_version' not in ip_profile:
 250                 ip_profile['ip_version'] = "IPv4"
 251             subnet={"name":net_name+"-subnet",
 252                     "network_id": new_net["network"]["id"],
 253                     "ip_version": 4 if ip_profile['ip_version']=="IPv4" else 6,
 254                     "cidr": ip_profile['subnet_address']
 255                     }
 256             if 'gateway_address' in ip_profile:
 257                 subnet['gateway_ip'] = ip_profile['gateway_address']
 258             if 'dns_address' in ip_profile:
 259                 #TODO: manage dns_address as a list of addresses separated by commas
 260                 subnet['dns_nameservers'] = []
 261                 subnet['dns_nameservers'].append(ip_profile['dns_address'])
 262             if 'dhcp_enabled' in ip_profile:
 263                 subnet['enable_dhcp'] = False if ip_profile['dhcp_enabled']=="false" else True
 264             if 'dhcp_start_address' in ip_profile:
 265                 subnet['allocation_pools']=[]
 266                 subnet['allocation_pools'].append(dict())
 267                 subnet['allocation_pools'][0]['start'] = ip_profile['dhcp_start_address']
 268             if 'dhcp_count' in ip_profile:
 269                 #parts = ip_profile['dhcp_start_address'].split('.')
 270                 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
 271                 ip_int = int(netaddr.IPAddress(ip_profile['dhcp_start_address']))
 272                 ip_int += ip_profile['dhcp_count']
 273                 ip_str = str(netaddr.IPAddress(ip_int))
 274                 subnet['allocation_pools'][0]['end'] = ip_str
 275             self.neutron.create_subnet({"subnet": subnet} )
 276             return new_net["network"]["id"]
 277         except (neExceptions.ConnectionFailed, ksExceptions.ClientException, neExceptions.NeutronException, ConnectionError) as e:
 278             self._format_exception(e)
 279
 280     def get_network_list(self, filter_dict={}):
 281         '''Obtain tenant networks of VIM
 282         Filter_dict can be:
 283             name: network name
 284             id: network uuid
 285             shared: boolean
 286             tenant_id: tenant
 287             admin_state_up: boolean
 288             status: 'ACTIVE'
 289         Returns the network list of dictionaries
 290         '''
 291         self.logger.debug("Getting network from VIM filter: '%s'", str(filter_dict))
 292         try:
 293             self._reload_connection()
 294             net_dict=self.neutron.list_networks(**filter_dict)
 295             net_list=net_dict["networks"]
 296             self.__net_os2mano(net_list)
 297             return net_list
 298         except (neExceptions.ConnectionFailed, ksExceptions.ClientException, neExceptions.NeutronException, ConnectionError) as e:
 299             self._format_exception(e)
 300
 301     def get_network(self, net_id):
 302         '''Obtain details of network from VIM
 303         Returns the network information from a network id'''
 304         self.logger.debug(" Getting tenant network %s from VIM", net_id)
 305         filter_dict={"id": net_id}
 306         net_list = self.get_network_list(filter_dict)
 307         if len(net_list)==0:
 308             raise vimconn.vimconnNotFoundException("Network '{}' not found".format(net_id))
 309         elif len(net_list)>1:
 310             raise vimconn.vimconnConflictException("Found more than one network with this criteria")
 311         net = net_list[0]
 312         subnets=[]
 313         for subnet_id in net.get("subnets", () ):
 314             try:
 315                 subnet = self.neutron.show_subnet(subnet_id)
 316             except Exception as e:
 317                 self.logger.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id, str(e)))
 318                 subnet = {"id": subnet_id, "fault": str(e)}
 319             subnets.append(subnet)
 320         net["subnets"] = subnets
 321         return net
 322
 323     def delete_network(self, net_id):
 324         '''Deletes a tenant network from VIM. Returns the old network identifier'''
 325         self.logger.debug("Deleting network '%s' from VIM", net_id)
 326         try:
 327             self._reload_connection()
 328             #delete VM ports attached to this networks before the network
 329             ports = self.neutron.list_ports(network_id=net_id)
 330             for p in ports['ports']:
 331                 try:
 332                     self.neutron.delete_port(p["id"])
 333                 except Exception as e:
 334                     self.logger.error("Error deleting port %s: %s", p["id"], str(e))
 335             self.neutron.delete_network(net_id)
 336             return net_id
 337         except (neExceptions.ConnectionFailed, neExceptions.NetworkNotFoundClient, neExceptions.NeutronException,
 338                 ksExceptions.ClientException, neExceptions.NeutronException, ConnectionError) as e:
 339             self._format_exception(e)
 340
 341     def refresh_nets_status(self, net_list):
 342         '''Get the status of the networks
 343            Params: the list of network identifiers
 344            Returns a dictionary with:
 345                 net_id:         #VIM id of this network
 346                     status:     #Mandatory. Text with one of:
 347                                 #  DELETED (not found at vim)
 348                                 #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
 349                                 #  OTHER (Vim reported other status not understood)
 350                                 #  ERROR (VIM indicates an ERROR status)
 351                                 #  ACTIVE, INACTIVE, DOWN (admin down),
 352                                 #  BUILD (on building process)
 353                                 #
 354                     error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
 355                     vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
 356
 357         '''
 358         net_dict={}
 359         for net_id in net_list:
 360             net = {}
 361             try:
 362                 net_vim = self.get_network(net_id)
 363                 if net_vim['status'] in netStatus2manoFormat:
 364                     net["status"] = netStatus2manoFormat[ net_vim['status'] ]
 365                 else:
 366                     net["status"] = "OTHER"
 367                     net["error_msg"] = "VIM status reported " + net_vim['status']
 368
 369                 if net['status'] == "ACTIVE" and not net_vim['admin_state_up']:
 370                     net['status'] = 'DOWN'
 371                 try:
 372                     net['vim_info'] = yaml.safe_dump(net_vim, default_flow_style=True, width=256)
 373                 except yaml.representer.RepresenterError:
 374                     net['vim_info'] = str(net_vim)
 375                 if net_vim.get('fault'):  #TODO
 376                     net['error_msg'] = str(net_vim['fault'])
 377             except vimconn.vimconnNotFoundException as e:
 378                 self.logger.error("Exception getting net status: %s", str(e))
 379                 net['status'] = "DELETED"
 380                 net['error_msg'] = str(e)
 381             except vimconn.vimconnException as e:
 382                 self.logger.error("Exception getting net status: %s", str(e))
 383                 net['status'] = "VIM_ERROR"
 384                 net['error_msg'] = str(e)
 385             net_dict[net_id] = net
 386         return net_dict
 387
 388     def get_flavor(self, flavor_id):
 389         '''Obtain flavor details from the  VIM. Returns the flavor dict details'''
 390         self.logger.debug("Getting flavor '%s'", flavor_id)
 391         try:
 392             self._reload_connection()
 393             flavor = self.nova.flavors.find(id=flavor_id)
 394             #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
 395             return flavor.to_dict()
 396         except (nvExceptions.NotFound, nvExceptions.ClientException, ksExceptions.ClientException, ConnectionError) as e:
 397             self._format_exception(e)
 398
 399     def new_flavor(self, flavor_data, change_name_if_used=True):
 400         '''Adds a tenant flavor to openstack VIM
 401         if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
 402         Returns the flavor identifier
 403         '''
 404         self.logger.debug("Adding flavor '%s'", str(flavor_data))
 405         retry=0
 406         max_retries=3
 407         name_suffix = 0
 408         name=flavor_data['name']
 409         while retry<max_retries:
 410             retry+=1
 411             try:
 412                 self._reload_connection()
 413                 if change_name_if_used:
 414                     #get used names
 415                     fl_names=[]
 416                     fl=self.nova.flavors.list()
 417                     for f in fl:
 418                         fl_names.append(f.name)
 419                     while name in fl_names:
 420                         name_suffix += 1
 421                         name = flavor_data['name']+"-" + str(name_suffix)
 422
 423                 ram = flavor_data.get('ram',64)
 424                 vcpus = flavor_data.get('vcpus',1)
 425                 numa_properties=None
 426
 427                 extended = flavor_data.get("extended")
 428                 if extended:
 429                     numas=extended.get("numas")
 430                     if numas:
 431                         numa_nodes = len(numas)
 432                         if numa_nodes > 1:
 433                             return -1, "Can not add flavor with more than one numa"
 434                         numa_properties = {"hw:numa_nodes":str(numa_nodes)}
 435                         numa_properties["hw:mem_page_size"] = "large"
 436                         numa_properties["hw:cpu_policy"] = "dedicated"
 437                         numa_properties["hw:numa_mempolicy"] = "strict"
 438                         for numa in numas:
 439                             #overwrite ram and vcpus
 440                             ram = numa['memory']*1024
 441                             if 'paired-threads' in numa:
 442                                 vcpus = numa['paired-threads']*2
 443                                 numa_properties["hw:cpu_threads_policy"] = "prefer"
 444                             elif 'cores' in numa:
 445                                 vcpus = numa['cores']
 446                                 #numa_properties["hw:cpu_threads_policy"] = "prefer"
 447                             elif 'threads' in numa:
 448                                 vcpus = numa['threads']
 449                                 numa_properties["hw:cpu_policy"] = "isolated"
 450                             for interface in numa.get("interfaces",() ):
 451                                 if interface["dedicated"]=="yes":
 452                                     raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
 453                                 #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
 454
 455                 #create flavor
 456                 new_flavor=self.nova.flavors.create(name,
 457                                 ram,
 458                                 vcpus,
 459                                 flavor_data.get('disk',1),
 460                                 is_public=flavor_data.get('is_public', True)
 461                             )
 462                 #add metadata
 463                 if numa_properties:
 464                     new_flavor.set_keys(numa_properties)
 465                 return new_flavor.id
 466             except nvExceptions.Conflict as e:
 467                 if change_name_if_used and retry < max_retries:
 468                     continue
 469                 self._format_exception(e)
 470             #except nvExceptions.BadRequest as e:
 471             except (ksExceptions.ClientException, nvExceptions.ClientException, ConnectionError) as e:
 472                 self._format_exception(e)
 473
 474     def delete_flavor(self,flavor_id):
 475         '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
 476         '''
 477         try:
 478             self._reload_connection()
 479             self.nova.flavors.delete(flavor_id)
 480             return flavor_id
 481         #except nvExceptions.BadRequest as e:
 482         except (nvExceptions.NotFound, ksExceptions.ClientException, nvExceptions.ClientException, ConnectionError) as e:
 483             self._format_exception(e)
 484
 485     def new_image(self,image_dict):
 486         '''
 487         Adds a tenant image to VIM. imge_dict is a dictionary with:
 488             name: name
 489             disk_format: qcow2, vhd, vmdk, raw (by default), ...
 490             location: path or URI
 491             public: "yes" or "no"
 492             metadata: metadata of the image
 493         Returns the image_id
 494         '''
 495         #using version 1 of glance client
 496         glancev1 = gl1Client.Client('1',self.glance_endpoint, token=self.keystone.auth_token, **self.k_creds)  #TODO check k_creds vs n_creds
 497         retry=0
 498         max_retries=3
 499         while retry<max_retries:
 500             retry+=1
 501             try:
 502                 self._reload_connection()
 503                 #determine format  http://docs.openstack.org/developer/glance/formats.html
 504                 if "disk_format" in image_dict:
 505                     disk_format=image_dict["disk_format"]
 506                 else: #autodiscover base on extention
 507                     if image_dict['location'][-6:]==".qcow2":
 508                         disk_format="qcow2"
 509                     elif image_dict['location'][-4:]==".vhd":
 510                         disk_format="vhd"
 511                     elif image_dict['location'][-5:]==".vmdk":
 512                         disk_format="vmdk"
 513                     elif image_dict['location'][-4:]==".vdi":
 514                         disk_format="vdi"
 515                     elif image_dict['location'][-4:]==".iso":
 516                         disk_format="iso"
 517                     elif image_dict['location'][-4:]==".aki":
 518                         disk_format="aki"
 519                     elif image_dict['location'][-4:]==".ari":
 520                         disk_format="ari"
 521                     elif image_dict['location'][-4:]==".ami":
 522                         disk_format="ami"
 523                     else:
 524                         disk_format="raw"
 525                 self.logger.debug("new_image: '%s' loading from '%s'", image_dict['name'], image_dict['location'])
 526                 if image_dict['location'][0:4]=="http":
 527                     new_image = glancev1.images.create(name=image_dict['name'], is_public=image_dict.get('public',"yes")=="yes",
 528                             container_format="bare", location=image_dict['location'], disk_format=disk_format)
 529                 else: #local path
 530                     with open(image_dict['location']) as fimage:
 531                         new_image = glancev1.images.create(name=image_dict['name'], is_public=image_dict.get('public',"yes")=="yes",
 532                             container_format="bare", data=fimage, disk_format=disk_format)
 533                 #insert metadata. We cannot use 'new_image.properties.setdefault'
 534                 #because nova and glance are "INDEPENDENT" and we are using nova for reading metadata
 535                 new_image_nova=self.nova.images.find(id=new_image.id)
 536                 new_image_nova.metadata.setdefault('location',image_dict['location'])
 537                 metadata_to_load = image_dict.get('metadata')
 538                 if metadata_to_load:
 539                     for k,v in yaml.load(metadata_to_load).iteritems():
 540                         new_image_nova.metadata.setdefault(k,v)
 541                 return new_image.id
 542             except (nvExceptions.Conflict, ksExceptions.ClientException, nvExceptions.ClientException) as e:
 543                 self._format_exception(e)
 544             except (HTTPException, gl1Exceptions.HTTPException, gl1Exceptions.CommunicationError, ConnectionError) as e:
 545                 if retry==max_retries:
 546                     continue
 547                 self._format_exception(e)
 548             except IOError as e:  #can not open the file
 549                 raise vimconn.vimconnConnectionException(type(e).__name__ + ": " + str(e)+ " for " + image_dict['location'],
 550                                                          http_code=vimconn.HTTP_Bad_Request)
 551
 552     def delete_image(self, image_id):
 553         '''Deletes a tenant image from openstack VIM. Returns the old id
 554         '''
 555         try:
 556             self._reload_connection()
 557             self.nova.images.delete(image_id)
 558             return image_id
 559         except (nvExceptions.NotFound, ksExceptions.ClientException, nvExceptions.ClientException, gl1Exceptions.CommunicationError, ConnectionError) as e: #TODO remove
 560             self._format_exception(e)
 561
 562     def get_image_id_from_path(self, path):
 563         '''Get the image id from image path in the VIM database. Returns the image_id
 564         '''
 565         try:
 566             self._reload_connection()
 567             images = self.nova.images.list()
 568             for image in images:
 569                 if image.metadata.get("location")==path:
 570                     return image.id
 571             raise vimconn.vimconnNotFoundException("image with location '{}' not found".format( path))
 572         except (ksExceptions.ClientException, nvExceptions.ClientException, gl1Exceptions.CommunicationError, ConnectionError) as e:
 573             self._format_exception(e)
 574
 575     def new_vminstance(self,name,description,start,image_id,flavor_id,net_list,cloud_config=None):
 576         '''Adds a VM instance to VIM
 577         Params:
 578             start: indicates if VM must start or boot in pause mode. Ignored
 579             image_id,flavor_id: iamge and flavor uuid
 580             net_list: list of interfaces, each one is a dictionary with:
 581                 name:
 582                 net_id: network uuid to connect
 583                 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
 584                 model: interface model, ignored #TODO
 585                 mac_address: used for  SR-IOV ifaces #TODO for other types
 586                 use: 'data', 'bridge',  'mgmt'
 587                 type: 'virtual', 'PF', 'VF', 'VFnotShared'
 588                 vim_id: filled/added by this function
 589                 #TODO ip, security groups
 590         Returns the instance identifier
 591         '''
 592         self.logger.debug("Creating VM image '%s' flavor '%s' nics='%s'",image_id, flavor_id,str(net_list))
 593         try:
 594             metadata={}
 595             net_list_vim=[]
 596             self._reload_connection()
 597             metadata_vpci={} #For a specific neutron plugin
 598             for net in net_list:
 599                 if not net.get("net_id"): #skip non connected iface
 600                     continue
 601                 if net["type"]=="virtual":
 602                     net_list_vim.append({'net-id': net["net_id"]})
 603                     if "vpci" in net:
 604                         metadata_vpci[ net["net_id"] ] = [[ net["vpci"], "" ]]
 605                 elif net["type"]=="PF":
 606                     self.logger.warn("new_vminstance: Warning, can not connect a passthrough interface ")
 607                     #TODO insert this when openstack consider passthrough ports as openstack neutron ports
 608                 else: #VF
 609                     if "vpci" in net:
 610                         if "VF" not in metadata_vpci:
 611                             metadata_vpci["VF"]=[]
 612                         metadata_vpci["VF"].append([ net["vpci"], "" ])
 613                     port_dict={
 614                          "network_id": net["net_id"],
 615                          "name": net.get("name"),
 616                          "binding:vnic_type": "direct",
 617                          "admin_state_up": True
 618                     }
 619                     if not port_dict["name"]:
 620                         port_dict["name"] = name
 621                     if net.get("mac_address"):
 622                         port_dict["mac_address"]=net["mac_address"]
 623                     #TODO: manage having SRIOV without vlan tag
 624                     #if net["type"] == "VFnotShared"
 625                     #    port_dict["vlan"]=0
 626                     new_port = self.neutron.create_port({"port": port_dict })
 627                     net["mac_adress"] = new_port["port"]["mac_address"]
 628                     net["vim_id"] = new_port["port"]["id"]
 629                     net["ip"] = new_port["port"].get("fixed_ips",[{}])[0].get("ip_address")
 630                     net_list_vim.append({"port-id": new_port["port"]["id"]})
 631             if metadata_vpci:
 632                 metadata = {"pci_assignement": json.dumps(metadata_vpci)}
 633                 if len(metadata["pci_assignement"]) >255:
 634                     #limit the metadata size
 635                     #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
 636                     self.logger.warn("Metadata deleted since it exceeds the expected length (255) ")
 637                     metadata = {}
 638
 639             self.logger.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s' metadata %s",
 640                               name, image_id, flavor_id, str(net_list_vim), description, str(metadata))
 641
 642             security_groups   = self.config.get('security_groups')
 643             if type(security_groups) is str:
 644                 security_groups = ( security_groups, )
 645             if isinstance(cloud_config, dict):
 646                 userdata="#cloud-config\nusers:\n"
 647                 #default user
 648                 if "key-pairs" in cloud_config:
 649                     userdata += "  - default:\n    ssh-authorized-keys:\n"
 650                     for key in cloud_config["key-pairs"]:
 651                         userdata += "      - '{key}'\n".format(key=key)
 652                 for user in cloud_config.get("users",[]):
 653                     userdata += "  - name: {name}\n    sudo: ALL=(ALL) NOPASSWD:ALL\n".format(name=user["name"])
 654                     if "user-info" in user:
 655                         userdata += "    gecos: {}'\n".format(user["user-info"])
 656                     if user.get("key-pairs"):
 657                         userdata += "    ssh-authorized-keys:\n"
 658                         for key in user["key-pairs"]:
 659                             userdata += "      - '{key}'\n".format(key=key)
 660                 self.logger.debug("userdata: %s", userdata)
 661             elif isinstance(cloud_config, str):
 662                 userdata = cloud_config
 663             else:
 664                 userdata=None
 665
 666             server = self.nova.servers.create(name, image_id, flavor_id, nics=net_list_vim, meta=metadata,
 667                                               security_groups   = security_groups,
 668                                               availability_zone = self.config.get('availability_zone'),
 669                                               key_name          = self.config.get('keypair'),
 670                                               userdata=userdata
 671                                         ) #, description=description)
 672
 673
 674             #print "DONE :-)", server
 675
 676 #             #TODO   server.add_floating_ip("10.95.87.209")
 677 #             #To look for a free floating_ip
 678 #             free_floating_ip = None
 679 #             for floating_ip in self.neutron.list_floatingips().get("floatingips", () ):
 680 #                 if not floating_ip["port_id"]:
 681 #                     free_floating_ip = floating_ip["floating_ip_address"]
 682 #                     break
 683 #             if free_floating_ip:
 684 #                 server.add_floating_ip(free_floating_ip)
 685
 686
 687             return server.id
 688 #        except nvExceptions.NotFound as e:
 689 #            error_value=-vimconn.HTTP_Not_Found
 690 #            error_text= "vm instance %s not found" % vm_id
 691         except (ksExceptions.ClientException, nvExceptions.ClientException, ConnectionError
 692                 ) as e:
 693             self._format_exception(e)
 694         except TypeError as e:
 695             raise vimconn.vimconnException(type(e).__name__ + ": "+  str(e), http_code=vimconn.HTTP_Bad_Request)
 696
 697     def get_vminstance(self,vm_id):
 698         '''Returns the VM instance information from VIM'''
 699         #self.logger.debug("Getting VM from VIM")
 700         try:
 701             self._reload_connection()
 702             server = self.nova.servers.find(id=vm_id)
 703             #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
 704             return server.to_dict()
 705         except (ksExceptions.ClientException, nvExceptions.ClientException, nvExceptions.NotFound, ConnectionError) as e:
 706             self._format_exception(e)
 707
 708     def get_vminstance_console(self,vm_id, console_type="vnc"):
 709         '''
 710         Get a console for the virtual machine
 711         Params:
 712             vm_id: uuid of the VM
 713             console_type, can be:
 714                 "novnc" (by default), "xvpvnc" for VNC types,
 715                 "rdp-html5" for RDP types, "spice-html5" for SPICE types
 716         Returns dict with the console parameters:
 717                 protocol: ssh, ftp, http, https, ...
 718                 server:   usually ip address
 719                 port:     the http, ssh, ... port
 720                 suffix:   extra text, e.g. the http path and query string
 721         '''
 722         self.logger.debug("Getting VM CONSOLE from VIM")
 723         try:
 724             self._reload_connection()
 725             server = self.nova.servers.find(id=vm_id)
 726             if console_type == None or console_type == "novnc":
 727                 console_dict = server.get_vnc_console("novnc")
 728             elif console_type == "xvpvnc":
 729                 console_dict = server.get_vnc_console(console_type)
 730             elif console_type == "rdp-html5":
 731                 console_dict = server.get_rdp_console(console_type)
 732             elif console_type == "spice-html5":
 733                 console_dict = server.get_spice_console(console_type)
 734             else:
 735                 raise vimconn.vimconnException("console type '{}' not allowed".format(console_type), http_code=vimconn.HTTP_Bad_Request)
 736
 737             console_dict1 = console_dict.get("console")
 738             if console_dict1:
 739                 console_url = console_dict1.get("url")
 740                 if console_url:
 741                     #parse console_url
 742                     protocol_index = console_url.find("//")
 743                     suffix_index = console_url[protocol_index+2:].find("/") + protocol_index+2
 744                     port_index = console_url[protocol_index+2:suffix_index].find(":") + protocol_index+2
 745                     if protocol_index < 0 or port_index<0 or suffix_index<0:
 746                         return -vimconn.HTTP_Internal_Server_Error, "Unexpected response from VIM"
 747                     console_dict={"protocol": console_url[0:protocol_index],
 748                                   "server":   console_url[protocol_index+2:port_index],
 749                                   "port":     console_url[port_index:suffix_index],
 750                                   "suffix":   console_url[suffix_index+1:]
 751                                   }
 752                     protocol_index += 2
 753                     return console_dict
 754             raise vimconn.vimconnUnexpectedResponse("Unexpected response from VIM")
 755
 756         except (nvExceptions.NotFound, ksExceptions.ClientException, nvExceptions.ClientException, nvExceptions.BadRequest, ConnectionError) as e:
 757             self._format_exception(e)
 758
 759     def delete_vminstance(self, vm_id):
 760         '''Removes a VM instance from VIM. Returns the old identifier
 761         '''
 762         #print "osconnector: Getting VM from VIM"
 763         try:
 764             self._reload_connection()
 765             #delete VM ports attached to this networks before the virtual machine
 766             ports = self.neutron.list_ports(device_id=vm_id)
 767             for p in ports['ports']:
 768                 try:
 769                     self.neutron.delete_port(p["id"])
 770                 except Exception as e:
 771                     self.logger.error("Error deleting port: " + type(e).__name__ + ": "+  str(e))
 772             self.nova.servers.delete(vm_id)
 773             return vm_id
 774         except (nvExceptions.NotFound, ksExceptions.ClientException, nvExceptions.ClientException, ConnectionError) as e:
 775             self._format_exception(e)
 776         #TODO insert exception vimconn.HTTP_Unauthorized
 777         #if reaching here is because an exception
 778
 779     def refresh_vms_status(self, vm_list):
 780         '''Get the status of the virtual machines and their interfaces/ports
 781            Params: the list of VM identifiers
 782            Returns a dictionary with:
 783                 vm_id:          #VIM id of this Virtual Machine
 784                     status:     #Mandatory. Text with one of:
 785                                 #  DELETED (not found at vim)
 786                                 #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
 787                                 #  OTHER (Vim reported other status not understood)
 788                                 #  ERROR (VIM indicates an ERROR status)
 789                                 #  ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
 790                                 #  CREATING (on building process), ERROR
 791                                 #  ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
 792                                 #
 793                     error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
 794                     vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
 795                     interfaces:
 796                      -  vim_info:         #Text with plain information obtained from vim (yaml.safe_dump)
 797                         mac_address:      #Text format XX:XX:XX:XX:XX:XX
 798                         vim_net_id:       #network id where this interface is connected
 799                         vim_interface_id: #interface/port VIM id
 800                         ip_address:       #null, or text with IPv4, IPv6 address
 801         '''
 802         vm_dict={}
 803         self.logger.debug("refresh_vms status: Getting tenant VM instance information from VIM")
 804         for vm_id in vm_list:
 805             vm={}
 806             try:
 807                 vm_vim = self.get_vminstance(vm_id)
 808                 if vm_vim['status'] in vmStatus2manoFormat:
 809                     vm['status']    =  vmStatus2manoFormat[ vm_vim['status'] ]
 810                 else:
 811                     vm['status']    = "OTHER"
 812                     vm['error_msg'] = "VIM status reported " + vm_vim['status']
 813                 try:
 814                     vm['vim_info']  = yaml.safe_dump(vm_vim, default_flow_style=True, width=256)
 815                 except yaml.representer.RepresenterError:
 816                     vm['vim_info'] = str(vm_vim)
 817                 vm["interfaces"] = []
 818                 if vm_vim.get('fault'):
 819                     vm['error_msg'] = str(vm_vim['fault'])
 820                 #get interfaces
 821                 try:
 822                     self._reload_connection()
 823                     port_dict=self.neutron.list_ports(device_id=vm_id)
 824                     for port in port_dict["ports"]:
 825                         interface={}
 826                         try:
 827                             interface['vim_info'] = yaml.safe_dump(port, default_flow_style=True, width=256)
 828                         except yaml.representer.RepresenterError:
 829                             interface['vim_info'] = str(port)
 830                         interface["mac_address"] = port.get("mac_address")
 831                         interface["vim_net_id"] = port["network_id"]
 832                         interface["vim_interface_id"] = port["id"]
 833                         ips=[]
 834                         #look for floating ip address
 835                         floating_ip_dict = self.neutron.list_floatingips(port_id=port["id"])
 836                         if floating_ip_dict.get("floatingips"):
 837                             ips.append(floating_ip_dict["floatingips"][0].get("floating_ip_address") )
 838
 839                         for subnet in port["fixed_ips"]:
 840                             ips.append(subnet["ip_address"])
 841                         interface["ip_address"] = ";".join(ips)
 842                         vm["interfaces"].append(interface)
 843                 except Exception as e:
 844                     self.logger.error("Error getting vm interface information " + type(e).__name__ + ": "+  str(e))
 845             except vimconn.vimconnNotFoundException as e:
 846                 self.logger.error("Exception getting vm status: %s", str(e))
 847                 vm['status'] = "DELETED"
 848                 vm['error_msg'] = str(e)
 849             except vimconn.vimconnException as e:
 850                 self.logger.error("Exception getting vm status: %s", str(e))
 851                 vm['status'] = "VIM_ERROR"
 852                 vm['error_msg'] = str(e)
 853             vm_dict[vm_id] = vm
 854         return vm_dict
 855
 856     def action_vminstance(self, vm_id, action_dict):
 857         '''Send and action over a VM instance from VIM
 858         Returns the vm_id if the action was successfully sent to the VIM'''
 859         self.logger.debug("Action over VM '%s': %s", vm_id, str(action_dict))
 860         try:
 861             self._reload_connection()
 862             server = self.nova.servers.find(id=vm_id)
 863             if "start" in action_dict:
 864                 if action_dict["start"]=="rebuild":
 865                     server.rebuild()
 866                 else:
 867                     if server.status=="PAUSED":
 868                         server.unpause()
 869                     elif server.status=="SUSPENDED":
 870                         server.resume()
 871                     elif server.status=="SHUTOFF":
 872                         server.start()
 873             elif "pause" in action_dict:
 874                 server.pause()
 875             elif "resume" in action_dict:
 876                 server.resume()
 877             elif "shutoff" in action_dict or "shutdown" in action_dict:
 878                 server.stop()
 879             elif "forceOff" in action_dict:
 880                 server.stop() #TODO
 881             elif "terminate" in action_dict:
 882                 server.delete()
 883             elif "createImage" in action_dict:
 884                 server.create_image()
 885                 #"path":path_schema,
 886                 #"description":description_schema,
 887                 #"name":name_schema,
 888                 #"metadata":metadata_schema,
 889                 #"imageRef": id_schema,
 890                 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
 891             elif "rebuild" in action_dict:
 892                 server.rebuild(server.image['id'])
 893             elif "reboot" in action_dict:
 894                 server.reboot() #reboot_type='SOFT'
 895             elif "console" in action_dict:
 896                 console_type = action_dict["console"]
 897                 if console_type == None or console_type == "novnc":
 898                     console_dict = server.get_vnc_console("novnc")
 899                 elif console_type == "xvpvnc":
 900                     console_dict = server.get_vnc_console(console_type)
 901                 elif console_type == "rdp-html5":
 902                     console_dict = server.get_rdp_console(console_type)
 903                 elif console_type == "spice-html5":
 904                     console_dict = server.get_spice_console(console_type)
 905                 else:
 906                     raise vimconn.vimconnException("console type '{}' not allowed".format(console_type),
 907                                                    http_code=vimconn.HTTP_Bad_Request)
 908                 try:
 909                     console_url = console_dict["console"]["url"]
 910                     #parse console_url
 911                     protocol_index = console_url.find("//")
 912                     suffix_index = console_url[protocol_index+2:].find("/") + protocol_index+2
 913                     port_index = console_url[protocol_index+2:suffix_index].find(":") + protocol_index+2
 914                     if protocol_index < 0 or port_index<0 or suffix_index<0:
 915                         raise vimconn.vimconnException("Unexpected response from VIM " + str(console_dict))
 916                     console_dict2={"protocol": console_url[0:protocol_index],
 917                                   "server":   console_url[protocol_index+2 : port_index],
 918                                   "port":     int(console_url[port_index+1 : suffix_index]),
 919                                   "suffix":   console_url[suffix_index+1:]
 920                                   }
 921                     return console_dict2
 922                 except Exception as e:
 923                     raise vimconn.vimconnException("Unexpected response from VIM " + str(console_dict))
 924
 925             return vm_id
 926         except (ksExceptions.ClientException, nvExceptions.ClientException, nvExceptions.NotFound, ConnectionError) as e:
 927             self._format_exception(e)
 928         #TODO insert exception vimconn.HTTP_Unauthorized
 929
 930 #NOT USED FUNCTIONS
 931
 932     def new_external_port(self, port_data):
 933         #TODO openstack if needed
 934         '''Adds a external port to VIM'''
 935         '''Returns the port identifier'''
 936         return -vimconn.HTTP_Internal_Server_Error, "osconnector.new_external_port() not implemented"
 937
 938     def connect_port_network(self, port_id, network_id, admin=False):
 939         #TODO openstack if needed
 940         '''Connects a external port to a network'''
 941         '''Returns status code of the VIM response'''
 942         return -vimconn.HTTP_Internal_Server_Error, "osconnector.connect_port_network() not implemented"
 943
 944     def new_user(self, user_name, user_passwd, tenant_id=None):
 945         '''Adds a new user to openstack VIM'''
 946         '''Returns the user identifier'''
 947         self.logger.debug("osconnector: Adding a new user to VIM")
 948         try:
 949             self._reload_connection()
 950             user=self.keystone.users.create(user_name, user_passwd, tenant_id=tenant_id)
 951             #self.keystone.tenants.add_user(self.k_creds["username"], #role)
 952             return user.id
 953         except ksExceptions.ConnectionError as e:
 954             error_value=-vimconn.HTTP_Bad_Request
 955             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
 956         except ksExceptions.ClientException as e: #TODO remove
 957             error_value=-vimconn.HTTP_Bad_Request
 958             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
 959         #TODO insert exception vimconn.HTTP_Unauthorized
 960         #if reaching here is because an exception
 961         if self.debug:
 962             self.logger.debug("new_user " + error_text)
 963         return error_value, error_text
 964
 965     def delete_user(self, user_id):
 966         '''Delete a user from openstack VIM'''
 967         '''Returns the user identifier'''
 968         if self.debug:
 969             print "osconnector: Deleting  a  user from VIM"
 970         try:
 971             self._reload_connection()
 972             self.keystone.users.delete(user_id)
 973             return 1, user_id
 974         except ksExceptions.ConnectionError as e:
 975             error_value=-vimconn.HTTP_Bad_Request
 976             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
 977         except ksExceptions.NotFound as e:
 978             error_value=-vimconn.HTTP_Not_Found
 979             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
 980         except ksExceptions.ClientException as e: #TODO remove
 981             error_value=-vimconn.HTTP_Bad_Request
 982             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
 983         #TODO insert exception vimconn.HTTP_Unauthorized
 984         #if reaching here is because an exception
 985         if self.debug:
 986             print "delete_tenant " + error_text
 987         return error_value, error_text
 988
 989     def get_hosts_info(self):
 990         '''Get the information of deployed hosts
 991         Returns the hosts content'''
 992         if self.debug:
 993             print "osconnector: Getting Host info from VIM"
 994         try:
 995             h_list=[]
 996             self._reload_connection()
 997             hypervisors = self.nova.hypervisors.list()
 998             for hype in hypervisors:
 999                 h_list.append( hype.to_dict() )
1000             return 1, {"hosts":h_list}
1001         except nvExceptions.NotFound as e:
1002             error_value=-vimconn.HTTP_Not_Found
1003             error_text= (str(e) if len(e.args)==0 else str(e.args[0]))
1004         except (ksExceptions.ClientException, nvExceptions.ClientException) as e:
1005             error_value=-vimconn.HTTP_Bad_Request
1006             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
1007         #TODO insert exception vimconn.HTTP_Unauthorized
1008         #if reaching here is because an exception
1009         if self.debug:
1010             print "get_hosts_info " + error_text
1011         return error_value, error_text
1012
1013     def get_hosts(self, vim_tenant):
1014         '''Get the hosts and deployed instances
1015         Returns the hosts content'''
1016         r, hype_dict = self.get_hosts_info()
1017         if r<0:
1018             return r, hype_dict
1019         hypervisors = hype_dict["hosts"]
1020         try:
1021             servers = self.nova.servers.list()
1022             for hype in hypervisors:
1023                 for server in servers:
1024                     if server.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype['hypervisor_hostname']:
1025                         if 'vm' in hype:
1026                             hype['vm'].append(server.id)
1027                         else:
1028                             hype['vm'] = [server.id]
1029             return 1, hype_dict
1030         except nvExceptions.NotFound as e:
1031             error_value=-vimconn.HTTP_Not_Found
1032             error_text= (str(e) if len(e.args)==0 else str(e.args[0]))
1033         except (ksExceptions.ClientException, nvExceptions.ClientException) as e:
1034             error_value=-vimconn.HTTP_Bad_Request
1035             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
1036         #TODO insert exception vimconn.HTTP_Unauthorized
1037         #if reaching here is because an exception
1038         if self.debug:
1039             print "get_hosts " + error_text
1040         return error_value, error_text
1041
1042