osm_ro/vimconn_openvim.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 vimconnector implements all the methods to interact with openvim using the openvim API.
  26 '''
  27 __author__="Alfonso Tierno, Gerardo Garcia"
  28 __date__ ="$26-aug-2014 11:09:29$"
  29
  30 import vimconn
  31 import requests
  32 import json
  33 import yaml
  34 import logging
  35 from openmano_schemas import id_schema, name_schema, nameshort_schema, description_schema, \
  36                             vlan1000_schema, integer0_schema
  37 from jsonschema import validate as js_v, exceptions as js_e
  38 from urllib import quote
  39
  40 '''contain the openvim virtual machine status to openmano status'''
  41 vmStatus2manoFormat={'ACTIVE':'ACTIVE',
  42                      'PAUSED':'PAUSED',
  43                      'SUSPENDED': 'SUSPENDED',
  44                      'INACTIVE':'INACTIVE',
  45                      'CREATING':'BUILD',
  46                      'ERROR':'ERROR','DELETED':'DELETED'
  47                      }
  48 netStatus2manoFormat={'ACTIVE':'ACTIVE','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED', 'DOWN':'DOWN'
  49                      }
  50
  51
  52 host_schema = {
  53     "type":"object",
  54     "properties":{
  55         "id": id_schema,
  56         "name": name_schema,
  57     },
  58     "required": ["id"]
  59 }
  60 image_schema = {
  61     "type":"object",
  62     "properties":{
  63         "id": id_schema,
  64         "name": name_schema,
  65     },
  66     "required": ["id","name"]
  67 }
  68 server_schema = {
  69     "type":"object",
  70     "properties":{
  71         "id":id_schema,
  72         "name": name_schema,
  73     },
  74     "required": ["id","name"]
  75 }
  76 new_host_response_schema = {
  77     "title":"host response information schema",
  78     "$schema": "http://json-schema.org/draft-04/schema#",
  79     "type":"object",
  80     "properties":{
  81         "host": host_schema
  82     },
  83     "required": ["host"],
  84     "additionalProperties": False
  85 }
  86
  87 get_images_response_schema = {
  88     "title":"openvim images response information schema",
  89     "$schema": "http://json-schema.org/draft-04/schema#",
  90     "type":"object",
  91     "properties":{
  92         "images":{
  93             "type":"array",
  94             "items": image_schema,
  95         }
  96     },
  97     "required": ["images"],
  98     "additionalProperties": False
  99 }
 100
 101 get_hosts_response_schema = {
 102     "title":"openvim hosts response information schema",
 103     "$schema": "http://json-schema.org/draft-04/schema#",
 104     "type":"object",
 105     "properties":{
 106         "hosts":{
 107             "type":"array",
 108             "items": host_schema,
 109         }
 110     },
 111     "required": ["hosts"],
 112     "additionalProperties": False
 113 }
 114
 115 get_host_detail_response_schema = new_host_response_schema # TODO: Content is not parsed yet
 116
 117 get_server_response_schema = {
 118     "title":"openvim server response information schema",
 119     "$schema": "http://json-schema.org/draft-04/schema#",
 120     "type":"object",
 121     "properties":{
 122         "servers":{
 123             "type":"array",
 124             "items": server_schema,
 125         }
 126     },
 127     "required": ["servers"],
 128     "additionalProperties": False
 129 }
 130
 131 new_tenant_response_schema = {
 132     "title":"tenant response information schema",
 133     "$schema": "http://json-schema.org/draft-04/schema#",
 134     "type":"object",
 135     "properties":{
 136         "tenant":{
 137             "type":"object",
 138             "properties":{
 139                 "id": id_schema,
 140                 "name": nameshort_schema,
 141                 "description":description_schema,
 142                 "enabled":{"type" : "boolean"}
 143             },
 144             "required": ["id"]
 145         }
 146     },
 147     "required": ["tenant"],
 148     "additionalProperties": False
 149 }
 150
 151 new_network_response_schema = {
 152     "title":"network response information schema",
 153     "$schema": "http://json-schema.org/draft-04/schema#",
 154     "type":"object",
 155     "properties":{
 156         "network":{
 157             "type":"object",
 158             "properties":{
 159                 "id":id_schema,
 160                 "name":name_schema,
 161                 "type":{"type":"string", "enum":["bridge_man","bridge_data","data", "ptp"]},
 162                 "shared":{"type":"boolean"},
 163                 "tenant_id":id_schema,
 164                 "admin_state_up":{"type":"boolean"},
 165                 "vlan":vlan1000_schema
 166             },
 167             "required": ["id"]
 168         }
 169     },
 170     "required": ["network"],
 171     "additionalProperties": False
 172 }
 173
 174
 175 # get_network_response_schema = {
 176 #     "title":"get network response information schema",
 177 #     "$schema": "http://json-schema.org/draft-04/schema#",
 178 #     "type":"object",
 179 #     "properties":{
 180 #         "network":{
 181 #             "type":"object",
 182 #             "properties":{
 183 #                 "id":id_schema,
 184 #                 "name":name_schema,
 185 #                 "type":{"type":"string", "enum":["bridge_man","bridge_data","data", "ptp"]},
 186 #                 "shared":{"type":"boolean"},
 187 #                 "tenant_id":id_schema,
 188 #                 "admin_state_up":{"type":"boolean"},
 189 #                 "vlan":vlan1000_schema
 190 #             },
 191 #             "required": ["id"]
 192 #         }
 193 #     },
 194 #     "required": ["network"],
 195 #     "additionalProperties": False
 196 # }
 197
 198
 199 new_port_response_schema = {
 200     "title":"port response information schema",
 201     "$schema": "http://json-schema.org/draft-04/schema#",
 202     "type":"object",
 203     "properties":{
 204         "port":{
 205             "type":"object",
 206             "properties":{
 207                 "id":id_schema,
 208             },
 209             "required": ["id"]
 210         }
 211     },
 212     "required": ["port"],
 213     "additionalProperties": False
 214 }
 215
 216 get_flavor_response_schema = {
 217     "title":"openvim flavors response information schema",
 218     "$schema": "http://json-schema.org/draft-04/schema#",
 219     "type":"object",
 220     "properties":{
 221         "flavor":{
 222             "type":"object",
 223             "properties":{
 224                 "id":   id_schema,
 225                 "name": name_schema,
 226                 "extended": {"type":"object"},
 227             },
 228             "required": ["id", "name"],
 229         }
 230     },
 231     "required": ["flavor"],
 232     "additionalProperties": False
 233 }
 234
 235 new_flavor_response_schema = {
 236     "title":"flavor response information schema",
 237     "$schema": "http://json-schema.org/draft-04/schema#",
 238     "type":"object",
 239     "properties":{
 240         "flavor":{
 241             "type":"object",
 242             "properties":{
 243                 "id":id_schema,
 244             },
 245             "required": ["id"]
 246         }
 247     },
 248     "required": ["flavor"],
 249     "additionalProperties": False
 250 }
 251
 252 get_image_response_schema = {
 253     "title":"openvim images response information schema",
 254     "$schema": "http://json-schema.org/draft-04/schema#",
 255     "type":"object",
 256     "properties":{
 257         "image":{
 258             "type":"object",
 259             "properties":{
 260                 "id":   id_schema,
 261                 "name": name_schema,
 262             },
 263             "required": ["id", "name"],
 264         }
 265     },
 266     "required": ["flavor"],
 267     "additionalProperties": False
 268 }
 269 new_image_response_schema = {
 270     "title":"image response information schema",
 271     "$schema": "http://json-schema.org/draft-04/schema#",
 272     "type":"object",
 273     "properties":{
 274         "image":{
 275             "type":"object",
 276             "properties":{
 277                 "id":id_schema,
 278             },
 279             "required": ["id"]
 280         }
 281     },
 282     "required": ["image"],
 283     "additionalProperties": False
 284 }
 285
 286 new_vminstance_response_schema = {
 287     "title":"server response information schema",
 288     "$schema": "http://json-schema.org/draft-04/schema#",
 289     "type":"object",
 290     "properties":{
 291         "server":{
 292             "type":"object",
 293             "properties":{
 294                 "id":id_schema,
 295             },
 296             "required": ["id"]
 297         }
 298     },
 299     "required": ["server"],
 300     "additionalProperties": False
 301 }
 302
 303 get_processor_rankings_response_schema = {
 304     "title":"processor rankings information schema",
 305     "$schema": "http://json-schema.org/draft-04/schema#",
 306     "type":"object",
 307     "properties":{
 308         "rankings":{
 309             "type":"array",
 310             "items":{
 311                 "type":"object",
 312                 "properties":{
 313                     "model": description_schema,
 314                     "value": integer0_schema
 315                 },
 316                 "additionalProperties": False,
 317                 "required": ["model","value"]
 318             }
 319         },
 320         "additionalProperties": False,
 321         "required": ["rankings"]
 322     }
 323 }
 324
 325 class vimconnector(vimconn.vimconnector):
 326     def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None,
 327                  log_level="DEBUG", config={}, persistent_info={}):
 328         vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level, config)
 329         self.tenant = None
 330         self.headers_req = {'content-type': 'application/json'}
 331         self.logger = logging.getLogger('openmano.vim.openvim')
 332         self.persistent_info = persistent_info
 333         if tenant_id:
 334             self.tenant = tenant_id
 335
 336     def __setitem__(self,index, value):
 337         '''Set individuals parameters
 338         Throw TypeError, KeyError
 339         '''
 340         if index=='tenant_id':
 341             self.tenant = value
 342         elif index=='tenant_name':
 343             self.tenant = None
 344         vimconn.vimconnector.__setitem__(self,index, value)
 345
 346     def _get_my_tenant(self):
 347         '''Obtain uuid of my tenant from name
 348         '''
 349         if self.tenant:
 350             return self.tenant
 351
 352         url = self.url+'/tenants?name='+ quote(self.tenant_name)
 353         self.logger.info("Getting VIM tenant_id GET %s", url)
 354         vim_response = requests.get(url, headers = self.headers_req)
 355         self._check_http_request_response(vim_response)
 356         try:
 357             tenant_list = vim_response.json()["tenants"]
 358             if len(tenant_list) == 0:
 359                 raise vimconn.vimconnNotFoundException("No tenant found for name '%s'" % str(self.tenant_name))
 360             elif len(tenant_list) > 1:
 361                 raise vimconn.vimconnConflictException ("More that one tenant found for name '%s'" % str(self.tenant_name))
 362             self.tenant = tenant_list[0]["id"]
 363             return self.tenant
 364         except Exception as e:
 365             raise vimconn.vimconnUnexpectedResponse("Get VIM tenant {} '{}'".format(type(e).__name__, str(e)))
 366
 367     def _format_jsonerror(self,http_response):
 368         #DEPRECATED, to delete in the future
 369         try:
 370             data = http_response.json()
 371             return data["error"]["description"]
 372         except:
 373             return http_response.text
 374
 375     def _format_in(self, http_response, schema):
 376         #DEPRECATED, to delete in the future
 377         try:
 378             client_data = http_response.json()
 379             js_v(client_data, schema)
 380             #print "Input data: ", str(client_data)
 381             return True, client_data
 382         except js_e.ValidationError as exc:
 383             print "validate_in error, jsonschema exception ", exc.message, "at", exc.path
 384             return False, ("validate_in error, jsonschema exception ", exc.message, "at", exc.path)
 385
 386     def _remove_extra_items(self, data, schema):
 387         deleted=[]
 388         if type(data) is tuple or type(data) is list:
 389             for d in data:
 390                 a= self._remove_extra_items(d, schema['items'])
 391                 if a is not None: deleted.append(a)
 392         elif type(data) is dict:
 393             for k in data.keys():
 394                 if 'properties' not in schema or k not in schema['properties'].keys():
 395                     del data[k]
 396                     deleted.append(k)
 397                 else:
 398                     a = self._remove_extra_items(data[k], schema['properties'][k])
 399                     if a is not None:  deleted.append({k:a})
 400         if len(deleted) == 0: return None
 401         elif len(deleted) == 1: return deleted[0]
 402         else: return deleted
 403
 404     def _format_request_exception(self, request_exception):
 405         '''Transform a request exception into a vimconn exception'''
 406         if isinstance(request_exception, js_e.ValidationError):
 407             raise vimconn.vimconnUnexpectedResponse("jsonschema exception '{}' at '{}'".format(request_exception.message, request_exception.path))
 408         elif isinstance(request_exception, requests.exceptions.HTTPError):
 409             raise vimconn.vimconnUnexpectedResponse(type(request_exception).__name__ + ": " + str(request_exception))
 410         else:
 411             raise vimconn.vimconnConnectionException(type(request_exception).__name__ + ": " + str(request_exception))
 412
 413     def _check_http_request_response(self, request_response):
 414         '''Raise a vimconn exception if the response is not Ok'''
 415         if request_response.status_code >= 200 and  request_response.status_code < 300:
 416             return
 417         if request_response.status_code == vimconn.HTTP_Unauthorized:
 418             raise vimconn.vimconnAuthException(request_response.text)
 419         elif request_response.status_code == vimconn.HTTP_Not_Found:
 420             raise vimconn.vimconnNotFoundException(request_response.text)
 421         elif request_response.status_code == vimconn.HTTP_Conflict:
 422             raise vimconn.vimconnConflictException(request_response.text)
 423         else:
 424             raise vimconn.vimconnUnexpectedResponse("VIM HTTP_response {}, {}".format(request_response.status_code, str(request_response.text)))
 425
 426     def new_tenant(self,tenant_name,tenant_description):
 427         '''Adds a new tenant to VIM with this name and description, returns the tenant identifier'''
 428         #print "VIMConnector: Adding a new tenant to VIM"
 429         payload_dict = {"tenant": {"name":tenant_name,"description": tenant_description, "enabled": True}}
 430         payload_req = json.dumps(payload_dict)
 431         try:
 432             url = self.url_admin+'/tenants'
 433             self.logger.info("Adding a new tenant %s", url)
 434             vim_response = requests.post(url, headers = self.headers_req, data=payload_req)
 435             self._check_http_request_response(vim_response)
 436             self.logger.debug(vim_response.text)
 437             #print json.dumps(vim_response.json(), indent=4)
 438             response = vim_response.json()
 439             js_v(response, new_tenant_response_schema)
 440             #r = self._remove_extra_items(response, new_tenant_response_schema)
 441             #if r is not None:
 442             #    self.logger.warn("Warning: remove extra items %s", str(r))
 443             tenant_id = response['tenant']['id']
 444             return tenant_id
 445         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 446             self._format_request_exception(e)
 447
 448     def delete_tenant(self,tenant_id):
 449         '''Delete a tenant from VIM. Returns the old tenant identifier'''
 450         try:
 451             url = self.url_admin+'/tenants/'+tenant_id
 452             self.logger.info("Delete a tenant DELETE %s", url)
 453             vim_response = requests.delete(url, headers = self.headers_req)
 454             self._check_http_request_response(vim_response)
 455             self.logger.debug(vim_response.text)
 456             #print json.dumps(vim_response.json(), indent=4)
 457             return tenant_id
 458         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 459             self._format_request_exception(e)
 460
 461     def get_tenant_list(self, filter_dict={}):
 462         '''Obtain tenants of VIM
 463         filter_dict can contain the following keys:
 464             name: filter by tenant name
 465             id: filter by tenant uuid/id
 466             <other VIM specific>
 467         Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
 468         '''
 469         filterquery=[]
 470         filterquery_text=''
 471         for k,v in filter_dict.iteritems():
 472             filterquery.append(str(k)+'='+str(v))
 473         if len(filterquery)>0:
 474             filterquery_text='?'+ '&'.join(filterquery)
 475         try:
 476             url = self.url+'/tenants'+filterquery_text
 477             self.logger.info("get_tenant_list GET %s", url)
 478             vim_response = requests.get(url, headers = self.headers_req)
 479             self._check_http_request_response(vim_response)
 480             self.logger.debug(vim_response.text)
 481             #print json.dumps(vim_response.json(), indent=4)
 482             return vim_response.json()["tenants"]
 483         except requests.exceptions.RequestException as e:
 484             self._format_request_exception(e)
 485
 486     def new_network(self,net_name, net_type, ip_profile=None, shared=False, vlan=None): #, **vim_specific):
 487         '''Adds a tenant network to VIM'''
 488         '''Returns the network identifier'''
 489         try:
 490             self._get_my_tenant()
 491             if net_type=="bridge":
 492                 net_type="bridge_data"
 493             payload_req = {"name": net_name, "type": net_type, "tenant_id": self.tenant, "shared": shared}
 494             if vlan:
 495                 payload_req["provider:vlan"] = vlan
 496             # payload_req.update(vim_specific)
 497             url = self.url+'/networks'
 498             self.logger.info("Adding a new network POST: %s  DATA: %s", url, str(payload_req))
 499             vim_response = requests.post(url, headers = self.headers_req, data=json.dumps({"network": payload_req}) )
 500             self._check_http_request_response(vim_response)
 501             self.logger.debug(vim_response.text)
 502             #print json.dumps(vim_response.json(), indent=4)
 503             response = vim_response.json()
 504             js_v(response, new_network_response_schema)
 505             #r = self._remove_extra_items(response, new_network_response_schema)
 506             #if r is not None:
 507             #    self.logger.warn("Warning: remove extra items %s", str(r))
 508             network_id = response['network']['id']
 509             return network_id
 510         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 511             self._format_request_exception(e)
 512
 513     def get_network_list(self, filter_dict={}):
 514         '''Obtain tenant networks of VIM
 515         Filter_dict can be:
 516             name: network name
 517             id: network uuid
 518             public: boolean
 519             tenant_id: tenant
 520             admin_state_up: boolean
 521             status: 'ACTIVE'
 522         Returns the network list of dictionaries
 523         '''
 524         try:
 525             if 'tenant_id' not in filter_dict:
 526                 filter_dict["tenant_id"] = self._get_my_tenant()
 527             elif not filter_dict["tenant_id"]:
 528                 del filter_dict["tenant_id"]
 529             filterquery=[]
 530             filterquery_text=''
 531             for k,v in filter_dict.iteritems():
 532                 filterquery.append(str(k)+'='+str(v))
 533             if len(filterquery)>0:
 534                 filterquery_text='?'+ '&'.join(filterquery)
 535             url = self.url+'/networks'+filterquery_text
 536             self.logger.info("Getting network list GET %s", url)
 537             vim_response = requests.get(url, headers = self.headers_req)
 538             self._check_http_request_response(vim_response)
 539             self.logger.debug(vim_response.text)
 540             #print json.dumps(vim_response.json(), indent=4)
 541             response = vim_response.json()
 542             return response['networks']
 543         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 544             self._format_request_exception(e)
 545
 546     def get_network(self, net_id):
 547         '''Obtain network details of network id'''
 548         try:
 549             url = self.url+'/networks/'+net_id
 550             self.logger.info("Getting network GET %s", url)
 551             vim_response = requests.get(url, headers = self.headers_req)
 552             self._check_http_request_response(vim_response)
 553             self.logger.debug(vim_response.text)
 554             #print json.dumps(vim_response.json(), indent=4)
 555             response = vim_response.json()
 556             return response['network']
 557         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 558             self._format_request_exception(e)
 559
 560     def delete_network(self, net_id):
 561         '''Deletes a tenant network from VIM'''
 562         '''Returns the network identifier'''
 563         try:
 564             self._get_my_tenant()
 565             url = self.url+'/networks/'+net_id
 566             self.logger.info("Deleting VIM network DELETE %s", url)
 567             vim_response = requests.delete(url, headers=self.headers_req)
 568             self._check_http_request_response(vim_response)
 569             #self.logger.debug(vim_response.text)
 570             #print json.dumps(vim_response.json(), indent=4)
 571             return net_id
 572         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 573             self._format_request_exception(e)
 574
 575     def get_flavor(self, flavor_id):
 576         '''Obtain flavor details from the  VIM'''
 577         try:
 578             self._get_my_tenant()
 579             url = self.url+'/'+self.tenant+'/flavors/'+flavor_id
 580             self.logger.info("Getting flavor GET %s", url)
 581             vim_response = requests.get(url, headers = self.headers_req)
 582             self._check_http_request_response(vim_response)
 583             self.logger.debug(vim_response.text)
 584             #print json.dumps(vim_response.json(), indent=4)
 585             response = vim_response.json()
 586             js_v(response, get_flavor_response_schema)
 587             r = self._remove_extra_items(response, get_flavor_response_schema)
 588             if r is not None:
 589                 self.logger.warn("Warning: remove extra items %s", str(r))
 590             return response['flavor']
 591         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 592             self._format_request_exception(e)
 593
 594     def new_flavor(self, flavor_data):
 595         '''Adds a tenant flavor to VIM'''
 596         '''Returns the flavor identifier'''
 597         try:
 598             new_flavor_dict = flavor_data.copy()
 599             for device in new_flavor_dict.get('extended', {}).get('devices', ()):
 600                 if 'image name' in device:
 601                     del device['image name']
 602             new_flavor_dict["name"] = flavor_data["name"][:64]
 603             self._get_my_tenant()
 604             payload_req = json.dumps({'flavor': new_flavor_dict})
 605             url = self.url+'/'+self.tenant+'/flavors'
 606             self.logger.info("Adding a new VIM flavor POST %s", url)
 607             vim_response = requests.post(url, headers = self.headers_req, data=payload_req)
 608             self._check_http_request_response(vim_response)
 609             self.logger.debug(vim_response.text)
 610             #print json.dumps(vim_response.json(), indent=4)
 611             response = vim_response.json()
 612             js_v(response, new_flavor_response_schema)
 613             r = self._remove_extra_items(response, new_flavor_response_schema)
 614             if r is not None:
 615                 self.logger.warn("Warning: remove extra items %s", str(r))
 616             flavor_id = response['flavor']['id']
 617             return flavor_id
 618         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 619             self._format_request_exception(e)
 620
 621     def delete_flavor(self,flavor_id):
 622         '''Deletes a tenant flavor from VIM'''
 623         '''Returns the old flavor_id'''
 624         try:
 625             self._get_my_tenant()
 626             url = self.url+'/'+self.tenant+'/flavors/'+flavor_id
 627             self.logger.info("Deleting VIM flavor DELETE %s", url)
 628             vim_response = requests.delete(url, headers=self.headers_req)
 629             self._check_http_request_response(vim_response)
 630             #self.logger.debug(vim_response.text)
 631             #print json.dumps(vim_response.json(), indent=4)
 632             return flavor_id
 633         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 634             self._format_request_exception(e)
 635
 636     def get_image(self, image_id):
 637         '''Obtain image details from the  VIM'''
 638         try:
 639             self._get_my_tenant()
 640             url = self.url+'/'+self.tenant+'/images/'+image_id
 641             self.logger.info("Getting image GET %s", url)
 642             vim_response = requests.get(url, headers = self.headers_req)
 643             self._check_http_request_response(vim_response)
 644             self.logger.debug(vim_response.text)
 645             #print json.dumps(vim_response.json(), indent=4)
 646             response = vim_response.json()
 647             js_v(response, get_image_response_schema)
 648             r = self._remove_extra_items(response, get_image_response_schema)
 649             if r is not None:
 650                 self.logger.warn("Warning: remove extra items %s", str(r))
 651             return response['image']
 652         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 653             self._format_request_exception(e)
 654
 655     def new_image(self,image_dict):
 656         ''' Adds a tenant image to VIM, returns image_id'''
 657         try:
 658             self._get_my_tenant()
 659             new_image_dict={'name': image_dict['name'][:64]}
 660             if image_dict.get('description'):
 661                 new_image_dict['description'] = image_dict['description']
 662             if image_dict.get('metadata'):
 663                 new_image_dict['metadata'] = yaml.load(image_dict['metadata'])
 664             if image_dict.get('location'):
 665                 new_image_dict['path'] = image_dict['location']
 666             payload_req = json.dumps({"image":new_image_dict})
 667             url=self.url + '/' + self.tenant + '/images'
 668             self.logger.info("Adding a new VIM image POST %s", url)
 669             vim_response = requests.post(url, headers = self.headers_req, data=payload_req)
 670             self._check_http_request_response(vim_response)
 671             self.logger.debug(vim_response.text)
 672             #print json.dumps(vim_response.json(), indent=4)
 673             response = vim_response.json()
 674             js_v(response, new_image_response_schema)
 675             r = self._remove_extra_items(response, new_image_response_schema)
 676             if r is not None:
 677                 self.logger.warn("Warning: remove extra items %s", str(r))
 678             image_id = response['image']['id']
 679             return image_id
 680         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 681             self._format_request_exception(e)
 682
 683     def delete_image(self, image_id):
 684         '''Deletes a tenant image from VIM'''
 685         '''Returns the deleted image_id'''
 686         try:
 687             self._get_my_tenant()
 688             url = self.url + '/'+ self.tenant +'/images/'+image_id
 689             self.logger.info("Deleting VIM image DELETE %s", url)
 690             vim_response = requests.delete(url, headers=self.headers_req)
 691             self._check_http_request_response(vim_response)
 692             #self.logger.debug(vim_response.text)
 693             #print json.dumps(vim_response.json(), indent=4)
 694             return image_id
 695         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 696             self._format_request_exception(e)
 697
 698     def get_image_id_from_path(self, path):
 699         '''Get the image id from image path in the VIM database. Returns the image_id'''
 700         try:
 701             self._get_my_tenant()
 702             url=self.url + '/' + self.tenant + '/images?path='+quote(path)
 703             self.logger.info("Getting images GET %s", url)
 704             vim_response = requests.get(url)
 705             self._check_http_request_response(vim_response)
 706             self.logger.debug(vim_response.text)
 707             #print json.dumps(vim_response.json(), indent=4)
 708             response = vim_response.json()
 709             js_v(response, get_images_response_schema)
 710             #r = self._remove_extra_items(response, get_images_response_schema)
 711             #if r is not None:
 712             #    self.logger.warn("Warning: remove extra items %s", str(r))
 713             if len(response['images'])==0:
 714                 raise vimconn.vimconnNotFoundException("Image not found at VIM with path '%s'", path)
 715             elif len(response['images'])>1:
 716                 raise vimconn.vimconnConflictException("More than one image found at VIM with path '%s'", path)
 717             return response['images'][0]['id']
 718         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 719             self._format_request_exception(e)
 720
 721     def get_image_list(self, filter_dict={}):
 722         '''Obtain tenant images from VIM
 723         Filter_dict can be:
 724             name: image name
 725             id: image uuid
 726             checksum: image checksum
 727             location: image path
 728         Returns the image list of dictionaries:
 729             [{<the fields at Filter_dict plus some VIM specific>}, ...]
 730             List can be empty
 731         '''
 732         try:
 733             self._get_my_tenant()
 734             filterquery=[]
 735             filterquery_text=''
 736             for k,v in filter_dict.iteritems():
 737                 filterquery.append(str(k)+'='+str(v))
 738             if len(filterquery)>0:
 739                 filterquery_text='?'+ '&'.join(filterquery)
 740             url = self.url+'/'+self.tenant+'/images'+filterquery_text
 741             self.logger.info("Getting image list GET %s", url)
 742             vim_response = requests.get(url, headers = self.headers_req)
 743             self._check_http_request_response(vim_response)
 744             self.logger.debug(vim_response.text)
 745             #print json.dumps(vim_response.json(), indent=4)
 746             response = vim_response.json()
 747             return response['images']
 748         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 749             self._format_request_exception(e)
 750
 751     def new_vminstancefromJSON(self, vm_data):
 752         '''Adds a VM instance to VIM'''
 753         '''Returns the instance identifier'''
 754         try:
 755             self._get_my_tenant()
 756         except Exception as e:
 757             return -vimconn.HTTP_Not_Found, str(e)
 758         print "VIMConnector: Adding a new VM instance from JSON to VIM"
 759         payload_req = vm_data
 760         try:
 761             vim_response = requests.post(self.url+'/'+self.tenant+'/servers', headers = self.headers_req, data=payload_req)
 762         except requests.exceptions.RequestException as e:
 763             print "new_vminstancefromJSON Exception: ", e.args
 764             return -vimconn.HTTP_Not_Found, str(e.args[0])
 765         print vim_response
 766         #print vim_response.status_code
 767         if vim_response.status_code == 200:
 768             #print vim_response.json()
 769             #print json.dumps(vim_response.json(), indent=4)
 770             res,http_content = self._format_in(vim_response, new_image_response_schema)
 771             #print http_content
 772             if res:
 773                 r = self._remove_extra_items(http_content, new_image_response_schema)
 774                 if r is not None: print "Warning: remove extra items ", r
 775                 #print http_content
 776                 vminstance_id = http_content['server']['id']
 777                 print "Tenant image id: ",vminstance_id
 778                 return vim_response.status_code,vminstance_id
 779             else: return -vimconn.HTTP_Bad_Request,http_content
 780         else:
 781             #print vim_response.text
 782             jsonerror = self._format_jsonerror(vim_response)
 783             text = 'Error in VIM "%s": not possible to add new vm instance. HTTP Response: %d. Error: %s' % (self.url, vim_response.status_code, jsonerror)
 784             #print text
 785             return -vim_response.status_code,text
 786
 787     def new_vminstance(self, name, description, start, image_id, flavor_id, net_list, cloud_config=None, disk_list=None,
 788                        availability_zone_index=None, availability_zone_list=None):
 789         '''Adds a VM instance to VIM
 790         Params:
 791             start: indicates if VM must start or boot in pause mode. Ignored
 792             image_id,flavor_id: image and flavor uuid
 793             net_list: list of interfaces, each one is a dictionary with:
 794                 name:
 795                 net_id: network uuid to connect
 796                 vpci: virtual vcpi to assign
 797                 model: interface model, virtio, e2000, ...
 798                 mac_address:
 799                 use: 'data', 'bridge',  'mgmt'
 800                 type: 'virtual', 'PF', 'VF', 'VFnotShared'
 801                 vim_id: filled/added by this function
 802                 #TODO ip, security groups
 803         Returns a tuple with the instance identifier and created_items or raises an exception on error
 804             created_items can be None or a dictionary where this method can include key-values that will be passed to
 805             the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
 806             Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
 807             as not present.
 808         '''
 809         self.logger.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'", image_id, flavor_id, str(net_list))
 810         try:
 811             self._get_my_tenant()
 812 #            net_list = []
 813 #            for k,v in net_dict.items():
 814 #                print k,v
 815 #                net_list.append('{"name":"' + k + '", "uuid":"' + v + '"}')
 816 #            net_list_string = ', '.join(net_list)
 817             virtio_net_list=[]
 818             for net in net_list:
 819                 if not net.get("net_id"):
 820                     continue
 821                 net_dict={'uuid': net["net_id"]}
 822                 if net.get("type"):        net_dict["type"] = net["type"]
 823                 if net.get("name"):        net_dict["name"] = net["name"]
 824                 if net.get("vpci"):        net_dict["vpci"] = net["vpci"]
 825                 if net.get("model"):       net_dict["model"] = net["model"]
 826                 if net.get("mac_address"): net_dict["mac_address"] = net["mac_address"]
 827                 virtio_net_list.append(net_dict)
 828             payload_dict={  "name":        name[:64],
 829                             "description": description,
 830                             "imageRef":    image_id,
 831                             "flavorRef":   flavor_id,
 832                             "networks": virtio_net_list
 833                         }
 834             if start != None:
 835                 payload_dict["start"] = start
 836             payload_req = json.dumps({"server": payload_dict})
 837             url = self.url+'/'+self.tenant+'/servers'
 838             self.logger.info("Adding a new vm POST %s DATA %s", url, payload_req)
 839             vim_response = requests.post(url, headers = self.headers_req, data=payload_req)
 840             self._check_http_request_response(vim_response)
 841             self.logger.debug(vim_response.text)
 842             #print json.dumps(vim_response.json(), indent=4)
 843             response = vim_response.json()
 844             js_v(response, new_vminstance_response_schema)
 845             #r = self._remove_extra_items(response, new_vminstance_response_schema)
 846             #if r is not None:
 847             #    self.logger.warn("Warning: remove extra items %s", str(r))
 848             vminstance_id = response['server']['id']
 849
 850             #connect data plane interfaces to network
 851             for net in net_list:
 852                 if net["type"]=="virtual":
 853                     if not net.get("net_id"):
 854                         continue
 855                     for iface in response['server']['networks']:
 856                         if "name" in net:
 857                             if net["name"]==iface["name"]:
 858                                 net["vim_id"] = iface['iface_id']
 859                                 break
 860                         elif "net_id" in net:
 861                             if net["net_id"]==iface["net_id"]:
 862                                 net["vim_id"] = iface['iface_id']
 863                                 break
 864                 else: #dataplane
 865                     for numa in response['server'].get('extended',{}).get('numas',() ):
 866                         for iface in numa.get('interfaces',() ):
 867                             if net['name'] == iface['name']:
 868                                 net['vim_id'] = iface['iface_id']
 869                                 #Code bellow is not needed, current openvim connect dataplane interfaces
 870                                 #if net.get("net_id"):
 871                                 ##connect dataplane interface
 872                                 #    result, port_id = self.connect_port_network(iface['iface_id'], net["net_id"])
 873                                 #    if result < 0:
 874                                 #        error_text = "Error attaching port %s to network %s: %s." % (iface['iface_id'], net["net_id"], port_id)
 875                                 #        print "new_vminstance: " + error_text
 876                                 #        self.delete_vminstance(vminstance_id)
 877                                 #        return result, error_text
 878                                 break
 879
 880             return vminstance_id, None
 881         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 882             self._format_request_exception(e)
 883
 884     def get_vminstance(self, vm_id):
 885         '''Returns the VM instance information from VIM'''
 886         try:
 887             self._get_my_tenant()
 888             url = self.url+'/'+self.tenant+'/servers/'+vm_id
 889             self.logger.info("Getting vm GET %s", url)
 890             vim_response = requests.get(url, headers = self.headers_req)
 891             vim_response = requests.get(url, headers = self.headers_req)
 892             self._check_http_request_response(vim_response)
 893             self.logger.debug(vim_response.text)
 894             #print json.dumps(vim_response.json(), indent=4)
 895             response = vim_response.json()
 896             js_v(response, new_vminstance_response_schema)
 897             #r = self._remove_extra_items(response, new_vminstance_response_schema)
 898             #if r is not None:
 899             #    self.logger.warn("Warning: remove extra items %s", str(r))
 900             return response['server']
 901         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 902             self._format_request_exception(e)
 903
 904     def delete_vminstance(self, vm_id, created_items=None):
 905         '''Removes a VM instance from VIM, returns the deleted vm_id'''
 906         try:
 907             self._get_my_tenant()
 908             url = self.url+'/'+self.tenant+'/servers/'+vm_id
 909             self.logger.info("Deleting VIM vm DELETE %s", url)
 910             vim_response = requests.delete(url, headers=self.headers_req)
 911             self._check_http_request_response(vim_response)
 912             #self.logger.debug(vim_response.text)
 913             #print json.dumps(vim_response.json(), indent=4)
 914             return vm_id
 915         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 916             self._format_request_exception(e)
 917
 918     def refresh_vms_status(self, vm_list):
 919         '''Refreshes the status of the virtual machines'''
 920         try:
 921             self._get_my_tenant()
 922         except requests.exceptions.RequestException as e:
 923             self._format_request_exception(e)
 924         vm_dict={}
 925         for vm_id in vm_list:
 926             vm={}
 927             #print "VIMConnector refresh_tenant_vms and nets: Getting tenant VM instance information from VIM"
 928             try:
 929                 url = self.url+'/'+self.tenant+'/servers/'+ vm_id
 930                 self.logger.info("Getting vm GET %s", url)
 931                 vim_response = requests.get(url, headers = self.headers_req)
 932                 self._check_http_request_response(vim_response)
 933                 response = vim_response.json()
 934                 js_v(response, new_vminstance_response_schema)
 935                 if response['server']['status'] in vmStatus2manoFormat:
 936                     vm['status'] = vmStatus2manoFormat[ response['server']['status']  ]
 937                 else:
 938                     vm['status'] = "OTHER"
 939                     vm['error_msg'] = "VIM status reported " + response['server']['status']
 940                 if response['server'].get('last_error'):
 941                     vm['error_msg'] = response['server']['last_error']
 942                 vm["vim_info"] = yaml.safe_dump(response['server'])
 943                 #get interfaces info
 944                 try:
 945                     management_ip = False
 946                     url2 = self.url+'/ports?device_id='+ quote(vm_id)
 947                     self.logger.info("Getting PORTS GET %s", url2)
 948                     vim_response2 = requests.get(url2, headers = self.headers_req)
 949                     self._check_http_request_response(vim_response2)
 950                     client_data = vim_response2.json()
 951                     if isinstance(client_data.get("ports"), list):
 952                         vm["interfaces"]=[]
 953                     for port in client_data.get("ports"):
 954                         interface={}
 955                         interface['vim_info']  = yaml.safe_dump(port)
 956                         interface["mac_address"] = port.get("mac_address")
 957                         interface["vim_net_id"] = port.get("network_id")
 958                         interface["vim_interface_id"] = port["id"]
 959                         interface["ip_address"] = port.get("ip_address")
 960                         if interface["ip_address"]:
 961                             management_ip = True
 962                         if interface["ip_address"] == "0.0.0.0":
 963                             interface["ip_address"] = None
 964                         vm["interfaces"].append(interface)
 965
 966                 except Exception as e:
 967                     self.logger.error("refresh_vms_and_nets. Port get %s: %s", type(e).__name__, str(e))
 968
 969                 if vm['status'] == "ACTIVE" and not management_ip:
 970                     vm['status'] = "ACTIVE:NoMgmtIP"
 971
 972             except vimconn.vimconnNotFoundException as e:
 973                 self.logger.error("Exception getting vm status: %s", str(e))
 974                 vm['status'] = "DELETED"
 975                 vm['error_msg'] = str(e)
 976             except (requests.exceptions.RequestException, js_e.ValidationError, vimconn.vimconnException) as e:
 977                 self.logger.error("Exception getting vm status: %s", str(e))
 978                 vm['status'] = "VIM_ERROR"
 979                 vm['error_msg'] = str(e)
 980             vm_dict[vm_id] = vm
 981         return vm_dict
 982
 983     def refresh_nets_status(self, net_list):
 984         '''Get the status of the networks
 985            Params: the list of network identifiers
 986            Returns a dictionary with:
 987                 net_id:         #VIM id of this network
 988                     status:     #Mandatory. Text with one of:
 989                                 #  DELETED (not found at vim)
 990                                 #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
 991                                 #  OTHER (Vim reported other status not understood)
 992                                 #  ERROR (VIM indicates an ERROR status)
 993                                 #  ACTIVE, INACTIVE, DOWN (admin down),
 994                                 #  BUILD (on building process)
 995                                 #
 996                     error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
 997                     vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
 998
 999         '''
1000         try:
1001             self._get_my_tenant()
1002         except requests.exceptions.RequestException as e:
1003             self._format_request_exception(e)
1004
1005         net_dict={}
1006         for net_id in net_list:
1007             net = {}
1008             #print "VIMConnector refresh_tenant_vms_and_nets: Getting tenant network from VIM (tenant: " + str(self.tenant) + "): "
1009             try:
1010                 net_vim = self.get_network(net_id)
1011                 if net_vim['status'] in netStatus2manoFormat:
1012                     net["status"] = netStatus2manoFormat[ net_vim['status'] ]
1013                 else:
1014                     net["status"] = "OTHER"
1015                     net["error_msg"] = "VIM status reported " + net_vim['status']
1016
1017                 if net["status"] == "ACTIVE" and not net_vim['admin_state_up']:
1018                     net["status"] = "DOWN"
1019                 if net_vim.get('last_error'):
1020                     net['error_msg'] = net_vim['last_error']
1021                 net["vim_info"] = yaml.safe_dump(net_vim)
1022             except vimconn.vimconnNotFoundException as e:
1023                 self.logger.error("Exception getting net status: %s", str(e))
1024                 net['status'] = "DELETED"
1025                 net['error_msg'] = str(e)
1026             except (requests.exceptions.RequestException, js_e.ValidationError, vimconn.vimconnException) as e:
1027                 self.logger.error("Exception getting net status: %s", str(e))
1028                 net['status'] = "VIM_ERROR"
1029                 net['error_msg'] = str(e)
1030             net_dict[net_id] = net
1031         return net_dict
1032
1033     def action_vminstance(self, vm_id, action_dict, created_items={}):
1034         '''Send and action over a VM instance from VIM'''
1035         '''Returns the status'''
1036         try:
1037             self._get_my_tenant()
1038             if "console" in action_dict:
1039                 raise vimconn.vimconnException("getting console is not available at openvim", http_code=vimconn.HTTP_Service_Unavailable)
1040             url = self.url+'/'+self.tenant+'/servers/'+vm_id+"/action"
1041             self.logger.info("Action over VM instance POST %s", url)
1042             vim_response = requests.post(url, headers = self.headers_req, data=json.dumps(action_dict) )
1043             self._check_http_request_response(vim_response)
1044             return None
1045         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
1046             self._format_request_exception(e)
1047
1048 #NOT USED METHODS in current version
1049
1050     def host_vim2gui(self, host, server_dict):
1051         '''Transform host dictionary from VIM format to GUI format,
1052         and append to the server_dict
1053         '''
1054         if type(server_dict) is not dict:
1055             print 'vimconnector.host_vim2gui() ERROR, param server_dict must be a dictionary'
1056             return
1057         RAD={}
1058         occupation={}
1059         for numa in host['host']['numas']:
1060             RAD_item={}
1061             occupation_item={}
1062             #memory
1063             RAD_item['memory']={'size': str(numa['memory'])+'GB', 'eligible': str(numa['hugepages'])+'GB'}
1064             occupation_item['memory']= str(numa['hugepages_consumed'])+'GB'
1065             #cpus
1066             RAD_item['cpus']={}
1067             RAD_item['cpus']['cores'] = []
1068             RAD_item['cpus']['eligible_cores'] = []
1069             occupation_item['cores']=[]
1070             for _ in range(0, len(numa['cores']) / 2):
1071                 RAD_item['cpus']['cores'].append( [] )
1072             for core in numa['cores']:
1073                 RAD_item['cpus']['cores'][core['core_id']].append(core['thread_id'])
1074                 if not 'status' in core: RAD_item['cpus']['eligible_cores'].append(core['thread_id'])
1075                 if 'instance_id' in core: occupation_item['cores'].append(core['thread_id'])
1076             #ports
1077             RAD_item['ports']={}
1078             occupation_item['ports']={}
1079             for iface in numa['interfaces']:
1080                 RAD_item['ports'][ iface['pci'] ] = 'speed:'+str(iface['Mbps'])+'M'
1081                 occupation_item['ports'][ iface['pci'] ] = { 'occupied': str(100*iface['Mbps_consumed'] / iface['Mbps']) + "%" }
1082
1083             RAD[ numa['numa_socket'] ] = RAD_item
1084             occupation[ numa['numa_socket'] ] = occupation_item
1085         server_dict[ host['host']['name'] ] = {'RAD':RAD, 'occupation':occupation}
1086
1087     def get_hosts_info(self):
1088         '''Get the information of deployed hosts
1089         Returns the hosts content'''
1090     #obtain hosts list
1091         url=self.url+'/hosts'
1092         try:
1093             vim_response = requests.get(url)
1094         except requests.exceptions.RequestException as e:
1095             print "get_hosts_info Exception: ", e.args
1096             return -vimconn.HTTP_Not_Found, str(e.args[0])
1097         print "vim get", url, "response:",  vim_response.status_code, vim_response.json()
1098         #print vim_response.status_code
1099         #print json.dumps(vim_response.json(), indent=4)
1100         if vim_response.status_code != 200:
1101             #TODO: get error
1102             print 'vimconnector.get_hosts_info error getting host list %d %s' %(vim_response.status_code, vim_response.json())
1103             return -vim_response.status_code, "Error getting host list"
1104
1105         res,hosts = self._format_in(vim_response, get_hosts_response_schema)
1106
1107         if res==False:
1108             print "vimconnector.get_hosts_info error parsing GET HOSTS vim response", hosts
1109             return vimconn.HTTP_Internal_Server_Error, hosts
1110     #obtain hosts details
1111         hosts_dict={}
1112         for host in hosts['hosts']:
1113             url=self.url+'/hosts/'+host['id']
1114             try:
1115                 vim_response = requests.get(url)
1116             except requests.exceptions.RequestException as e:
1117                 print "get_hosts_info Exception: ", e.args
1118                 return -vimconn.HTTP_Not_Found, str(e.args[0])
1119             print "vim get", url, "response:",  vim_response.status_code, vim_response.json()
1120             if vim_response.status_code != 200:
1121                 print 'vimconnector.get_hosts_info error getting detailed host %d %s' %(vim_response.status_code, vim_response.json())
1122                 continue
1123             res,host_detail = self._format_in(vim_response, get_host_detail_response_schema)
1124             if res==False:
1125                 print "vimconnector.get_hosts_info error parsing GET HOSTS/%s vim response" % host['id'], host_detail
1126                 continue
1127             #print 'host id '+host['id'], json.dumps(host_detail, indent=4)
1128             self.host_vim2gui(host_detail, hosts_dict)
1129         return 200, hosts_dict
1130
1131     def get_hosts(self, vim_tenant):
1132         '''Get the hosts and deployed instances
1133         Returns the hosts content'''
1134     #obtain hosts list
1135         url=self.url+'/hosts'
1136         try:
1137             vim_response = requests.get(url)
1138         except requests.exceptions.RequestException as e:
1139             print "get_hosts Exception: ", e.args
1140             return -vimconn.HTTP_Not_Found, str(e.args[0])
1141         print "vim get", url, "response:",  vim_response.status_code, vim_response.json()
1142         #print vim_response.status_code
1143         #print json.dumps(vim_response.json(), indent=4)
1144         if vim_response.status_code != 200:
1145             #TODO: get error
1146             print 'vimconnector.get_hosts error getting host list %d %s' %(vim_response.status_code, vim_response.json())
1147             return -vim_response.status_code, "Error getting host list"
1148
1149         res,hosts = self._format_in(vim_response, get_hosts_response_schema)
1150
1151         if res==False:
1152             print "vimconnector.get_host error parsing GET HOSTS vim response", hosts
1153             return vimconn.HTTP_Internal_Server_Error, hosts
1154     #obtain instances from hosts
1155         for host in hosts['hosts']:
1156             url=self.url+'/' + vim_tenant + '/servers?hostId='+host['id']
1157             try:
1158                 vim_response = requests.get(url)
1159             except requests.exceptions.RequestException as e:
1160                 print "get_hosts Exception: ", e.args
1161                 return -vimconn.HTTP_Not_Found, str(e.args[0])
1162             print "vim get", url, "response:",  vim_response.status_code, vim_response.json()
1163             if vim_response.status_code != 200:
1164                 print 'vimconnector.get_hosts error getting instances at host %d %s' %(vim_response.status_code, vim_response.json())
1165                 continue
1166             res,servers = self._format_in(vim_response, get_server_response_schema)
1167             if res==False:
1168                 print "vimconnector.get_host error parsing GET SERVERS/%s vim response" % host['id'], servers
1169                 continue
1170             #print 'host id '+host['id'], json.dumps(host_detail, indent=4)
1171             host['instances'] = servers['servers']
1172         return 200, hosts['hosts']
1173
1174     def get_processor_rankings(self):
1175         '''Get the processor rankings in the VIM database'''
1176         url=self.url+'/processor_ranking'
1177         try:
1178             vim_response = requests.get(url)
1179         except requests.exceptions.RequestException as e:
1180             print "get_processor_rankings Exception: ", e.args
1181             return -vimconn.HTTP_Not_Found, str(e.args[0])
1182         print "vim get", url, "response:", vim_response.status_code, vim_response.json()
1183         #print vim_response.status_code
1184         #print json.dumps(vim_response.json(), indent=4)
1185         if vim_response.status_code != 200:
1186             #TODO: get error
1187             print 'vimconnector.get_processor_rankings error getting processor rankings %d %s' %(vim_response.status_code, vim_response.json())
1188             return -vim_response.status_code, "Error getting processor rankings"
1189
1190         res,rankings = self._format_in(vim_response, get_processor_rankings_response_schema)
1191         return res, rankings['rankings']
1192
1193     def new_host(self, host_data):
1194         '''Adds a new host to VIM'''
1195         '''Returns status code of the VIM response'''
1196         payload_req = host_data
1197         try:
1198             url = self.url_admin+'/hosts'
1199             self.logger.info("Adding a new host POST %s", url)
1200             vim_response = requests.post(url, headers = self.headers_req, data=payload_req)
1201             self._check_http_request_response(vim_response)
1202             self.logger.debug(vim_response.text)
1203             #print json.dumps(vim_response.json(), indent=4)
1204             response = vim_response.json()
1205             js_v(response, new_host_response_schema)
1206             r = self._remove_extra_items(response, new_host_response_schema)
1207             if r is not None:
1208                 self.logger.warn("Warning: remove extra items %s", str(r))
1209             host_id = response['host']['id']
1210             return host_id
1211         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
1212             self._format_request_exception(e)
1213
1214     def new_external_port(self, port_data):
1215         '''Adds a external port to VIM'''
1216         '''Returns the port identifier'''
1217         #TODO change to logging exception code policies
1218         print "VIMConnector: Adding a new external port"
1219         payload_req = port_data
1220         try:
1221             vim_response = requests.post(self.url_admin+'/ports', headers = self.headers_req, data=payload_req)
1222         except requests.exceptions.RequestException as e:
1223             self.logger.error("new_external_port Exception: ", str(e))
1224             return -vimconn.HTTP_Not_Found, str(e.args[0])
1225         print vim_response
1226         #print vim_response.status_code
1227         if vim_response.status_code == 200:
1228         #print vim_response.json()
1229         #print json.dumps(vim_response.json(), indent=4)
1230             res, http_content = self._format_in(vim_response, new_port_response_schema)
1231         #print http_content
1232             if res:
1233                 r = self._remove_extra_items(http_content, new_port_response_schema)
1234                 if r is not None: print "Warning: remove extra items ", r
1235                 #print http_content
1236                 port_id = http_content['port']['id']
1237                 print "Port id: ",port_id
1238                 return vim_response.status_code,port_id
1239             else: return -vimconn.HTTP_Bad_Request,http_content
1240         else:
1241             #print vim_response.text
1242             jsonerror = self._format_jsonerror(vim_response)
1243             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)
1244             #print text
1245             return -vim_response.status_code,text
1246
1247     def new_external_network(self,net_name,net_type):
1248         '''Adds a external network to VIM (shared)'''
1249         '''Returns the network identifier'''
1250         #TODO change to logging exception code policies
1251         print "VIMConnector: Adding external shared network to VIM (type " + net_type + "): "+ net_name
1252
1253         payload_req = '{"network":{"name": "' + net_name + '","shared":true,"type": "' + net_type + '"}}'
1254         try:
1255             vim_response = requests.post(self.url+'/networks', headers = self.headers_req, data=payload_req)
1256         except requests.exceptions.RequestException as e:
1257             self.logger.error( "new_external_network Exception: ", e.args)
1258             return -vimconn.HTTP_Not_Found, str(e.args[0])
1259         print vim_response
1260         #print vim_response.status_code
1261         if vim_response.status_code == 200:
1262             #print vim_response.json()
1263             #print json.dumps(vim_response.json(), indent=4)
1264             res,http_content = self._format_in(vim_response, new_network_response_schema)
1265             #print http_content
1266             if res:
1267                 r = self._remove_extra_items(http_content, new_network_response_schema)
1268                 if r is not None: print "Warning: remove extra items ", r
1269                 #print http_content
1270                 network_id = http_content['network']['id']
1271                 print "Network id: ",network_id
1272                 return vim_response.status_code,network_id
1273             else: return -vimconn.HTTP_Bad_Request,http_content
1274         else:
1275             #print vim_response.text
1276             jsonerror = self._format_jsonerror(vim_response)
1277             text = 'Error in VIM "%s": not possible to add new external network. HTTP Response: %d. Error: %s' % (self.url, vim_response.status_code, jsonerror)
1278             #print text
1279             return -vim_response.status_code,text
1280
1281     def connect_port_network(self, port_id, network_id, admin=False):
1282         '''Connects a external port to a network'''
1283         '''Returns status code of the VIM response'''
1284         #TODO change to logging exception code policies
1285         print "VIMConnector: Connecting external port to network"
1286
1287         payload_req = '{"port":{"network_id":"' + network_id + '"}}'
1288         if admin:
1289             if self.url_admin==None:
1290                 return -vimconn.HTTP_Unauthorized, "datacenter cannot contain  admin URL"
1291             url= self.url_admin
1292         else:
1293             url= self.url
1294         try:
1295             vim_response = requests.put(url +'/ports/'+port_id, headers = self.headers_req, data=payload_req)
1296         except requests.exceptions.RequestException as e:
1297             print "connect_port_network Exception: ", e.args
1298             return -vimconn.HTTP_Not_Found, str(e.args[0])
1299         print vim_response
1300         #print vim_response.status_code
1301         if vim_response.status_code == 200:
1302             #print vim_response.json()
1303             #print json.dumps(vim_response.json(), indent=4)
1304             res,http_content = self._format_in(vim_response, new_port_response_schema)
1305             #print http_content
1306             if res:
1307                 r = self._remove_extra_items(http_content, new_port_response_schema)
1308                 if r is not None: print "Warning: remove extra items ", r
1309                 #print http_content
1310                 port_id = http_content['port']['id']
1311                 print "Port id: ",port_id
1312                 return vim_response.status_code,port_id
1313             else: return -vimconn.HTTP_Bad_Request,http_content
1314         else:
1315             print vim_response.text
1316             jsonerror = self._format_jsonerror(vim_response)
1317             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)
1318             print text
1319             return -vim_response.status_code,text
1320
1321