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