RO-VIM-openvim/osm_rovim_openvim/vimconn_openvim.py

   1 # -*- coding: utf-8 -*-
   2
   3 ##
   4 # Copyright 2015 Telefonica Investigacion 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 json
  31 import logging
  32 import math
  33 from urllib.parse import quote
  34
  35 from jsonschema import exceptions as js_e, validate as js_v
  36 from osm_ro.openmano_schemas import (
  37     description_schema,
  38     id_schema,
  39     integer0_schema,
  40     name_schema,
  41     nameshort_schema,
  42     vlan1000_schema,
  43 )
  44 from osm_ro_plugin import vimconn
  45 import requests
  46 import yaml
  47
  48 """contain the openvim virtual machine status to openmano status"""
  49 vmStatus2manoFormat = {
  50     "ACTIVE": "ACTIVE",
  51     "PAUSED": "PAUSED",
  52     "SUSPENDED": "SUSPENDED",
  53     "INACTIVE": "INACTIVE",
  54     "CREATING": "BUILD",
  55     "ERROR": "ERROR",
  56     "DELETED": "DELETED",
  57 }
  58 netStatus2manoFormat = {
  59     "ACTIVE": "ACTIVE",
  60     "INACTIVE": "INACTIVE",
  61     "BUILD": "BUILD",
  62     "ERROR": "ERROR",
  63     "DELETED": "DELETED",
  64     "DOWN": "DOWN",
  65 }
  66
  67
  68 host_schema = {
  69     "type": "object",
  70     "properties": {
  71         "id": id_schema,
  72         "name": name_schema,
  73     },
  74     "required": ["id"],
  75 }
  76 image_schema = {
  77     "type": "object",
  78     "properties": {
  79         "id": id_schema,
  80         "name": name_schema,
  81     },
  82     "required": ["id", "name"],
  83 }
  84 server_schema = {
  85     "type": "object",
  86     "properties": {
  87         "id": id_schema,
  88         "name": name_schema,
  89     },
  90     "required": ["id", "name"],
  91 }
  92 new_host_response_schema = {
  93     "title": "host response information schema",
  94     "$schema": "http://json-schema.org/draft-04/schema#",
  95     "type": "object",
  96     "properties": {"host": host_schema},
  97     "required": ["host"],
  98     "additionalProperties": False,
  99 }
 100
 101 get_images_response_schema = {
 102     "title": "openvim images response information schema",
 103     "$schema": "http://json-schema.org/draft-04/schema#",
 104     "type": "object",
 105     "properties": {
 106         "images": {
 107             "type": "array",
 108             "items": image_schema,
 109         }
 110     },
 111     "required": ["images"],
 112     "additionalProperties": False,
 113 }
 114
 115 get_hosts_response_schema = {
 116     "title": "openvim hosts response information schema",
 117     "$schema": "http://json-schema.org/draft-04/schema#",
 118     "type": "object",
 119     "properties": {
 120         "hosts": {
 121             "type": "array",
 122             "items": host_schema,
 123         }
 124     },
 125     "required": ["hosts"],
 126     "additionalProperties": False,
 127 }
 128
 129 get_host_detail_response_schema = (
 130     new_host_response_schema  # TODO: Content is not parsed yet
 131 )
 132
 133 get_server_response_schema = {
 134     "title": "openvim server response information schema",
 135     "$schema": "http://json-schema.org/draft-04/schema#",
 136     "type": "object",
 137     "properties": {
 138         "servers": {
 139             "type": "array",
 140             "items": server_schema,
 141         }
 142     },
 143     "required": ["servers"],
 144     "additionalProperties": False,
 145 }
 146
 147 new_tenant_response_schema = {
 148     "title": "tenant response information schema",
 149     "$schema": "http://json-schema.org/draft-04/schema#",
 150     "type": "object",
 151     "properties": {
 152         "tenant": {
 153             "type": "object",
 154             "properties": {
 155                 "id": id_schema,
 156                 "name": nameshort_schema,
 157                 "description": description_schema,
 158                 "enabled": {"type": "boolean"},
 159             },
 160             "required": ["id"],
 161         }
 162     },
 163     "required": ["tenant"],
 164     "additionalProperties": False,
 165 }
 166
 167 new_network_response_schema = {
 168     "title": "network response information schema",
 169     "$schema": "http://json-schema.org/draft-04/schema#",
 170     "type": "object",
 171     "properties": {
 172         "network": {
 173             "type": "object",
 174             "properties": {
 175                 "id": id_schema,
 176                 "name": name_schema,
 177                 "type": {
 178                     "type": "string",
 179                     "enum": ["bridge_man", "bridge_data", "data", "ptp"],
 180                 },
 181                 "shared": {"type": "boolean"},
 182                 "tenant_id": id_schema,
 183                 "admin_state_up": {"type": "boolean"},
 184                 "vlan": vlan1000_schema,
 185             },
 186             "required": ["id"],
 187         }
 188     },
 189     "required": ["network"],
 190     "additionalProperties": False,
 191 }
 192
 193
 194 # get_network_response_schema = {
 195 #     "title":"get network response information schema",
 196 #     "$schema": "http://json-schema.org/draft-04/schema#",
 197 #     "type":"object",
 198 #     "properties":{
 199 #         "network":{
 200 #             "type":"object",
 201 #             "properties":{
 202 #                 "id":id_schema,
 203 #                 "name":name_schema,
 204 #                 "type":{"type":"string", "enum":["bridge_man","bridge_data","data", "ptp"]},
 205 #                 "shared":{"type":"boolean"},
 206 #                 "tenant_id":id_schema,
 207 #                 "admin_state_up":{"type":"boolean"},
 208 #                 "vlan":vlan1000_schema
 209 #             },
 210 #             "required": ["id"]
 211 #         }
 212 #     },
 213 #     "required": ["network"],
 214 #     "additionalProperties": False
 215 # }
 216
 217
 218 new_port_response_schema = {
 219     "title": "port response information schema",
 220     "$schema": "http://json-schema.org/draft-04/schema#",
 221     "type": "object",
 222     "properties": {
 223         "port": {
 224             "type": "object",
 225             "properties": {
 226                 "id": id_schema,
 227             },
 228             "required": ["id"],
 229         }
 230     },
 231     "required": ["port"],
 232     "additionalProperties": False,
 233 }
 234
 235 get_flavor_response_schema = {
 236     "title": "openvim flavors 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                 "name": name_schema,
 245                 "extended": {"type": "object"},
 246             },
 247             "required": ["id", "name"],
 248         }
 249     },
 250     "required": ["flavor"],
 251     "additionalProperties": False,
 252 }
 253
 254 new_flavor_response_schema = {
 255     "title": "flavor response information schema",
 256     "$schema": "http://json-schema.org/draft-04/schema#",
 257     "type": "object",
 258     "properties": {
 259         "flavor": {
 260             "type": "object",
 261             "properties": {
 262                 "id": id_schema,
 263             },
 264             "required": ["id"],
 265         }
 266     },
 267     "required": ["flavor"],
 268     "additionalProperties": False,
 269 }
 270
 271 get_image_response_schema = {
 272     "title": "openvim images response information schema",
 273     "$schema": "http://json-schema.org/draft-04/schema#",
 274     "type": "object",
 275     "properties": {
 276         "image": {
 277             "type": "object",
 278             "properties": {
 279                 "id": id_schema,
 280                 "name": name_schema,
 281             },
 282             "required": ["id", "name"],
 283         }
 284     },
 285     "required": ["flavor"],
 286     "additionalProperties": False,
 287 }
 288 new_image_response_schema = {
 289     "title": "image response information schema",
 290     "$schema": "http://json-schema.org/draft-04/schema#",
 291     "type": "object",
 292     "properties": {
 293         "image": {
 294             "type": "object",
 295             "properties": {
 296                 "id": id_schema,
 297             },
 298             "required": ["id"],
 299         }
 300     },
 301     "required": ["image"],
 302     "additionalProperties": False,
 303 }
 304
 305 new_vminstance_response_schema = {
 306     "title": "server response information schema",
 307     "$schema": "http://json-schema.org/draft-04/schema#",
 308     "type": "object",
 309     "properties": {
 310         "server": {
 311             "type": "object",
 312             "properties": {
 313                 "id": id_schema,
 314             },
 315             "required": ["id"],
 316         }
 317     },
 318     "required": ["server"],
 319     "additionalProperties": False,
 320 }
 321
 322 get_processor_rankings_response_schema = {
 323     "title": "processor rankings information schema",
 324     "$schema": "http://json-schema.org/draft-04/schema#",
 325     "type": "object",
 326     "properties": {
 327         "rankings": {
 328             "type": "array",
 329             "items": {
 330                 "type": "object",
 331                 "properties": {"model": description_schema, "value": integer0_schema},
 332                 "additionalProperties": False,
 333                 "required": ["model", "value"],
 334             },
 335         },
 336         "additionalProperties": False,
 337         "required": ["rankings"],
 338     },
 339 }
 340
 341
 342 class vimconnector(vimconn.VimConnector):
 343     def __init__(
 344         self,
 345         uuid,
 346         name,
 347         tenant_id,
 348         tenant_name,
 349         url,
 350         url_admin=None,
 351         user=None,
 352         passwd=None,
 353         log_level="DEBUG",
 354         config={},
 355         persistent_info={},
 356     ):
 357         vimconn.VimConnector.__init__(
 358             self,
 359             uuid,
 360             name,
 361             tenant_id,
 362             tenant_name,
 363             url,
 364             url_admin,
 365             user,
 366             passwd,
 367             log_level,
 368             config,
 369         )
 370         self.tenant = None
 371         self.headers_req = {"content-type": "application/json"}
 372         self.logger = logging.getLogger("ro.vim.openvim")
 373         self.persistent_info = persistent_info
 374         if tenant_id:
 375             self.tenant = tenant_id
 376
 377     def __setitem__(self, index, value):
 378         """Set individuals parameters
 379         Throw TypeError, KeyError
 380         """
 381         if index == "tenant_id":
 382             self.tenant = value
 383         elif index == "tenant_name":
 384             self.tenant = None
 385         vimconn.VimConnector.__setitem__(self, index, value)
 386
 387     def _get_my_tenant(self):
 388         """Obtain uuid of my tenant from name"""
 389         if self.tenant:
 390             return self.tenant
 391
 392         url = self.url + "/tenants?name=" + quote(self.tenant_name)
 393         self.logger.info("Getting VIM tenant_id GET %s", url)
 394         vim_response = requests.get(url, headers=self.headers_req)
 395         self._check_http_request_response(vim_response)
 396         try:
 397             tenant_list = vim_response.json()["tenants"]
 398             if len(tenant_list) == 0:
 399                 raise vimconn.VimConnNotFoundException(
 400                     "No tenant found for name '{}'".format(self.tenant_name)
 401                 )
 402             elif len(tenant_list) > 1:
 403                 raise vimconn.VimConnConflictException(
 404                     "More that one tenant found for name '{}'".format(self.tenant_name)
 405                 )
 406             self.tenant = tenant_list[0]["id"]
 407             return self.tenant
 408         except Exception as e:
 409             raise vimconn.VimConnUnexpectedResponse(
 410                 "Get VIM tenant {} '{}'".format(type(e).__name__, str(e))
 411             )
 412
 413     def _format_jsonerror(self, http_response):
 414         # DEPRECATED, to delete in the future
 415         try:
 416             data = http_response.json()
 417             return data["error"]["description"]
 418         except Exception:
 419             return http_response.text
 420
 421     def _format_in(self, http_response, schema):
 422         # DEPRECATED, to delete in the future
 423         try:
 424             client_data = http_response.json()
 425             js_v(client_data, schema)
 426             # print "Input data: ", str(client_data)
 427             return True, client_data
 428         except js_e.ValidationError as exc:
 429             print(
 430                 "validate_in error, jsonschema exception ", exc.message, "at", exc.path
 431             )
 432             return False, (
 433                 "validate_in error, jsonschema exception ",
 434                 exc.message,
 435                 "at",
 436                 exc.path,
 437             )
 438
 439     def _remove_extra_items(self, data, schema):
 440         deleted = []
 441         if type(data) is tuple or type(data) is list:
 442             for d in data:
 443                 a = self._remove_extra_items(d, schema["items"])
 444                 if a is not None:
 445                     deleted.append(a)
 446         elif type(data) is dict:
 447             to_delete = []
 448             for k in data.keys():
 449                 if "properties" not in schema or k not in schema["properties"].keys():
 450                     to_delete.append(k)
 451                     deleted.append(k)
 452                 else:
 453                     a = self._remove_extra_items(data[k], schema["properties"][k])
 454                     if a is not None:
 455                         deleted.append({k: a})
 456             for k in to_delete:
 457                 del data[k]
 458         if len(deleted) == 0:
 459             return None
 460         elif len(deleted) == 1:
 461             return deleted[0]
 462         else:
 463             return deleted
 464
 465     def _format_request_exception(self, request_exception):
 466         """Transform a request exception into a vimconn exception"""
 467         if isinstance(request_exception, js_e.ValidationError):
 468             raise vimconn.VimConnUnexpectedResponse(
 469                 "jsonschema exception '{}' at '{}'".format(
 470                     request_exception.message, request_exception.path
 471                 )
 472             )
 473         elif isinstance(request_exception, requests.exceptions.HTTPError):
 474             raise vimconn.VimConnUnexpectedResponse(
 475                 type(request_exception).__name__ + ": " + str(request_exception)
 476             )
 477         else:
 478             raise vimconn.VimConnConnectionException(
 479                 type(request_exception).__name__ + ": " + str(request_exception)
 480             )
 481
 482     def _check_http_request_response(self, request_response):
 483         """Raise a vimconn exception if the response is not Ok"""
 484         if request_response.status_code >= 200 and request_response.status_code < 300:
 485             return
 486         if request_response.status_code == vimconn.HTTP_Unauthorized:
 487             raise vimconn.VimConnAuthException(request_response.text)
 488         elif request_response.status_code == vimconn.HTTP_Not_Found:
 489             raise vimconn.VimConnNotFoundException(request_response.text)
 490         elif request_response.status_code == vimconn.HTTP_Conflict:
 491             raise vimconn.VimConnConflictException(request_response.text)
 492         else:
 493             raise vimconn.VimConnUnexpectedResponse(
 494                 "VIM HTTP_response {}, {}".format(
 495                     request_response.status_code, str(request_response.text)
 496                 )
 497             )
 498
 499     def new_tenant(self, tenant_name, tenant_description):
 500         """Adds a new tenant to VIM with this name and description, returns the tenant identifier"""
 501         # print "VIMConnector: Adding a new tenant to VIM"
 502         payload_dict = {
 503             "tenant": {
 504                 "name": tenant_name,
 505                 "description": tenant_description,
 506                 "enabled": True,
 507             }
 508         }
 509         payload_req = json.dumps(payload_dict)
 510         try:
 511             url = self.url_admin + "/tenants"
 512             self.logger.info("Adding a new tenant %s", url)
 513             vim_response = requests.post(
 514                 url, headers=self.headers_req, data=payload_req
 515             )
 516             self._check_http_request_response(vim_response)
 517             self.logger.debug(vim_response.text)
 518             # print json.dumps(vim_response.json(), indent=4)
 519             response = vim_response.json()
 520             js_v(response, new_tenant_response_schema)
 521             # r = self._remove_extra_items(response, new_tenant_response_schema)
 522             # if r is not None:
 523             #    self.logger.warn("Warning: remove extra items %s", str(r))
 524             tenant_id = response["tenant"]["id"]
 525             return tenant_id
 526         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 527             self._format_request_exception(e)
 528
 529     def delete_tenant(self, tenant_id):
 530         """Delete a tenant from VIM. Returns the old tenant identifier"""
 531         try:
 532             url = self.url_admin + "/tenants/" + tenant_id
 533             self.logger.info("Delete a tenant DELETE %s", url)
 534             vim_response = requests.delete(url, headers=self.headers_req)
 535             self._check_http_request_response(vim_response)
 536             self.logger.debug(vim_response.text)
 537             # print json.dumps(vim_response.json(), indent=4)
 538             return tenant_id
 539         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 540             self._format_request_exception(e)
 541
 542     def get_tenant_list(self, filter_dict={}):
 543         """Obtain tenants of VIM
 544         filter_dict can contain the following keys:
 545             name: filter by tenant name
 546             id: filter by tenant uuid/id
 547             <other VIM specific>
 548         Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
 549         """
 550         filterquery = []
 551         filterquery_text = ""
 552         for k, v in filter_dict.items():
 553             filterquery.append(str(k) + "=" + str(v))
 554         if len(filterquery) > 0:
 555             filterquery_text = "?" + "&".join(filterquery)
 556         try:
 557             url = self.url + "/tenants" + filterquery_text
 558             self.logger.info("get_tenant_list GET %s", url)
 559             vim_response = requests.get(url, headers=self.headers_req)
 560             self._check_http_request_response(vim_response)
 561             self.logger.debug(vim_response.text)
 562             # print json.dumps(vim_response.json(), indent=4)
 563             return vim_response.json()["tenants"]
 564         except requests.exceptions.RequestException as e:
 565             self._format_request_exception(e)
 566
 567     def new_network(
 568         self,
 569         net_name,
 570         net_type,
 571         ip_profile=None,
 572         shared=False,
 573         provider_network_profile=None,
 574     ):  # , **vim_specific):
 575         """Adds a tenant network to VIM
 576         Params:
 577             'net_name': name of the network
 578             'net_type': one of:
 579                 'bridge': overlay isolated network
 580                 'data':   underlay E-LAN network for Passthrough and SRIOV interfaces
 581                 'ptp':    underlay E-LINE network for Passthrough and SRIOV interfaces.
 582             'ip_profile': is a dict containing the IP parameters of the network
 583                 'ip_version': can be "IPv4" or "IPv6" (Currently only IPv4 is implemented)
 584                 'subnet_address': ip_prefix_schema, that is X.X.X.X/Y
 585                 'gateway_address': (Optional) ip_schema, that is X.X.X.X
 586                 'dns_address': (Optional) comma separated list of ip_schema, e.g. X.X.X.X[,X,X,X,X]
 587                 'dhcp_enabled': True or False
 588                 'dhcp_start_address': ip_schema, first IP to grant
 589                 'dhcp_count': number of IPs to grant.
 590             'shared': if this network can be seen/use by other tenants/organization
 591             'provider_network_profile': (optional) contains {segmentation-id: vlan, provider-network: vim_netowrk}
 592         Returns a tuple with the network identifier and created_items, or raises an exception on error
 593             created_items can be None or a dictionary where this method can include key-values that will be passed to
 594             the method delete_network. Can be used to store created segments, created l2gw connections, etc.
 595             Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
 596             as not present.
 597         """
 598         try:
 599             vlan = None
 600             if provider_network_profile:
 601                 vlan = provider_network_profile.get("segmentation-id")
 602             created_items = {}
 603             self._get_my_tenant()
 604             if net_type == "bridge":
 605                 net_type = "bridge_data"
 606             payload_req = {
 607                 "name": net_name,
 608                 "type": net_type,
 609                 "tenant_id": self.tenant,
 610                 "shared": shared,
 611             }
 612             if vlan:
 613                 payload_req["provider:vlan"] = vlan
 614             # payload_req.update(vim_specific)
 615             url = self.url + "/networks"
 616             self.logger.info(
 617                 "Adding a new network POST: %s  DATA: %s", url, str(payload_req)
 618             )
 619             vim_response = requests.post(
 620                 url, headers=self.headers_req, data=json.dumps({"network": payload_req})
 621             )
 622             self._check_http_request_response(vim_response)
 623             self.logger.debug(vim_response.text)
 624             # print json.dumps(vim_response.json(), indent=4)
 625             response = vim_response.json()
 626             js_v(response, new_network_response_schema)
 627             # r = self._remove_extra_items(response, new_network_response_schema)
 628             # if r is not None:
 629             #    self.logger.warn("Warning: remove extra items %s", str(r))
 630             network_id = response["network"]["id"]
 631             return network_id, created_items
 632         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 633             self._format_request_exception(e)
 634
 635     def get_network_list(self, filter_dict={}):
 636         """Obtain tenant networks of VIM
 637         Filter_dict can be:
 638             name: network name
 639             id: network uuid
 640             public: boolean
 641             tenant_id: tenant
 642             admin_state_up: boolean
 643             status: 'ACTIVE'
 644         Returns the network list of dictionaries
 645         """
 646         try:
 647             if "tenant_id" not in filter_dict:
 648                 filter_dict["tenant_id"] = self._get_my_tenant()
 649             elif not filter_dict["tenant_id"]:
 650                 del filter_dict["tenant_id"]
 651             filterquery = []
 652             filterquery_text = ""
 653             for k, v in filter_dict.items():
 654                 filterquery.append(str(k) + "=" + str(v))
 655             if len(filterquery) > 0:
 656                 filterquery_text = "?" + "&".join(filterquery)
 657             url = self.url + "/networks" + filterquery_text
 658             self.logger.info("Getting network list GET %s", url)
 659             vim_response = requests.get(url, headers=self.headers_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             return response["networks"]
 665         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 666             self._format_request_exception(e)
 667
 668     def get_network(self, net_id):
 669         """Obtain network details of network id"""
 670         try:
 671             url = self.url + "/networks/" + net_id
 672             self.logger.info("Getting network GET %s", url)
 673             vim_response = requests.get(url, headers=self.headers_req)
 674             self._check_http_request_response(vim_response)
 675             self.logger.debug(vim_response.text)
 676             # print json.dumps(vim_response.json(), indent=4)
 677             response = vim_response.json()
 678             return response["network"]
 679         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 680             self._format_request_exception(e)
 681
 682     def delete_network(self, net_id, created_items=None):
 683         """
 684         Removes a tenant network from VIM and its associated elements
 685         :param net_id: VIM identifier of the network, provided by method new_network
 686         :param created_items: dictionary with extra items to be deleted. provided by method new_network
 687         Returns the network identifier or raises an exception upon error or when network is not found
 688         """
 689         try:
 690             self._get_my_tenant()
 691             url = self.url + "/networks/" + net_id
 692             self.logger.info("Deleting VIM network DELETE %s", url)
 693             vim_response = requests.delete(url, headers=self.headers_req)
 694             self._check_http_request_response(vim_response)
 695             # self.logger.debug(vim_response.text)
 696             # print json.dumps(vim_response.json(), indent=4)
 697             return net_id
 698         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 699             self._format_request_exception(e)
 700
 701     def get_flavor(self, flavor_id):
 702         """Obtain flavor details from the  VIM"""
 703         try:
 704             self._get_my_tenant()
 705             url = self.url + "/" + self.tenant + "/flavors/" + flavor_id
 706             self.logger.info("Getting flavor GET %s", url)
 707             vim_response = requests.get(url, headers=self.headers_req)
 708             self._check_http_request_response(vim_response)
 709             self.logger.debug(vim_response.text)
 710             # print json.dumps(vim_response.json(), indent=4)
 711             response = vim_response.json()
 712             js_v(response, get_flavor_response_schema)
 713             r = self._remove_extra_items(response, get_flavor_response_schema)
 714             if r is not None:
 715                 self.logger.warn("Warning: remove extra items %s", str(r))
 716             return response["flavor"]
 717         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 718             self._format_request_exception(e)
 719
 720     def new_flavor(self, flavor_data):
 721         """Adds a tenant flavor to VIM"""
 722         """Returns the flavor identifier"""
 723         try:
 724             new_flavor_dict = flavor_data.copy()
 725             for device in new_flavor_dict.get("extended", {}).get("devices", ()):
 726                 if "image name" in device:
 727                     del device["image name"]
 728                 if "name" in device:
 729                     del device["name"]
 730             numas = new_flavor_dict.get("extended", {}).get("numas")
 731             if numas:
 732                 numa = numas[0]
 733                 # translate memory, cpus to EPA
 734                 if (
 735                     "cores" not in numa
 736                     and "threads" not in numa
 737                     and "paired-threads" not in numa
 738                 ):
 739                     numa["paired-threads"] = new_flavor_dict["vcpus"]
 740                 if "memory" not in numa:
 741                     numa["memory"] = int(math.ceil(new_flavor_dict["ram"] / 1024.0))
 742                 for iface in numa.get("interfaces", ()):
 743                     if not iface.get("bandwidth"):
 744                         iface["bandwidth"] = "1 Mbps"
 745
 746             new_flavor_dict["name"] = flavor_data["name"][:64]
 747             self._get_my_tenant()
 748             payload_req = json.dumps({"flavor": new_flavor_dict})
 749             url = self.url + "/" + self.tenant + "/flavors"
 750             self.logger.info("Adding a new VIM flavor POST %s", url)
 751             vim_response = requests.post(
 752                 url, headers=self.headers_req, data=payload_req
 753             )
 754             self._check_http_request_response(vim_response)
 755             self.logger.debug(vim_response.text)
 756             # print json.dumps(vim_response.json(), indent=4)
 757             response = vim_response.json()
 758             js_v(response, new_flavor_response_schema)
 759             r = self._remove_extra_items(response, new_flavor_response_schema)
 760             if r is not None:
 761                 self.logger.warn("Warning: remove extra items %s", str(r))
 762             flavor_id = response["flavor"]["id"]
 763             return flavor_id
 764         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 765             self._format_request_exception(e)
 766
 767     def delete_flavor(self, flavor_id):
 768         """Deletes a tenant flavor from VIM"""
 769         """Returns the old flavor_id"""
 770         try:
 771             self._get_my_tenant()
 772             url = self.url + "/" + self.tenant + "/flavors/" + flavor_id
 773             self.logger.info("Deleting VIM flavor DELETE %s", url)
 774             vim_response = requests.delete(url, headers=self.headers_req)
 775             self._check_http_request_response(vim_response)
 776             # self.logger.debug(vim_response.text)
 777             # print json.dumps(vim_response.json(), indent=4)
 778             return flavor_id
 779         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 780             self._format_request_exception(e)
 781
 782     def get_image(self, image_id):
 783         """Obtain image details from the  VIM"""
 784         try:
 785             self._get_my_tenant()
 786             url = self.url + "/" + self.tenant + "/images/" + image_id
 787             self.logger.info("Getting image GET %s", url)
 788             vim_response = requests.get(url, headers=self.headers_req)
 789             self._check_http_request_response(vim_response)
 790             self.logger.debug(vim_response.text)
 791             # print json.dumps(vim_response.json(), indent=4)
 792             response = vim_response.json()
 793             js_v(response, get_image_response_schema)
 794             r = self._remove_extra_items(response, get_image_response_schema)
 795             if r is not None:
 796                 self.logger.warn("Warning: remove extra items %s", str(r))
 797             return response["image"]
 798         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 799             self._format_request_exception(e)
 800
 801     def new_image(self, image_dict):
 802         """Adds a tenant image to VIM, returns image_id"""
 803         try:
 804             self._get_my_tenant()
 805             new_image_dict = {"name": image_dict["name"][:64]}
 806             if image_dict.get("description"):
 807                 new_image_dict["description"] = image_dict["description"]
 808             if image_dict.get("metadata"):
 809                 new_image_dict["metadata"] = yaml.load(
 810                     image_dict["metadata"], Loader=yaml.SafeLoader
 811                 )
 812             if image_dict.get("location"):
 813                 new_image_dict["path"] = image_dict["location"]
 814             payload_req = json.dumps({"image": new_image_dict})
 815             url = self.url + "/" + self.tenant + "/images"
 816             self.logger.info("Adding a new VIM image POST %s", url)
 817             vim_response = requests.post(
 818                 url, headers=self.headers_req, data=payload_req
 819             )
 820             self._check_http_request_response(vim_response)
 821             self.logger.debug(vim_response.text)
 822             # print json.dumps(vim_response.json(), indent=4)
 823             response = vim_response.json()
 824             js_v(response, new_image_response_schema)
 825             r = self._remove_extra_items(response, new_image_response_schema)
 826             if r is not None:
 827                 self.logger.warn("Warning: remove extra items %s", str(r))
 828             image_id = response["image"]["id"]
 829             return image_id
 830         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 831             self._format_request_exception(e)
 832
 833     def delete_image(self, image_id):
 834         """Deletes a tenant image from VIM"""
 835         """Returns the deleted image_id"""
 836         try:
 837             self._get_my_tenant()
 838             url = self.url + "/" + self.tenant + "/images/" + image_id
 839             self.logger.info("Deleting VIM image DELETE %s", url)
 840             vim_response = requests.delete(url, headers=self.headers_req)
 841             self._check_http_request_response(vim_response)
 842             # self.logger.debug(vim_response.text)
 843             # print json.dumps(vim_response.json(), indent=4)
 844             return image_id
 845         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 846             self._format_request_exception(e)
 847
 848     def get_image_id_from_path(self, path):
 849         """Get the image id from image path in the VIM database. Returns the image_id"""
 850         try:
 851             self._get_my_tenant()
 852             url = self.url + "/" + self.tenant + "/images?path=" + quote(path)
 853             self.logger.info("Getting images GET %s", url)
 854             vim_response = requests.get(url)
 855             self._check_http_request_response(vim_response)
 856             self.logger.debug(vim_response.text)
 857             # print json.dumps(vim_response.json(), indent=4)
 858             response = vim_response.json()
 859             js_v(response, get_images_response_schema)
 860             # r = self._remove_extra_items(response, get_images_response_schema)
 861             # if r is not None:
 862             #    self.logger.warn("Warning: remove extra items %s", str(r))
 863             if len(response["images"]) == 0:
 864                 raise vimconn.VimConnNotFoundException(
 865                     "Image not found at VIM with path '{}'".format(path)
 866                 )
 867             elif len(response["images"]) > 1:
 868                 raise vimconn.VimConnConflictException(
 869                     "More than one image found at VIM with path '{}'".format(path)
 870                 )
 871             return response["images"][0]["id"]
 872         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 873             self._format_request_exception(e)
 874
 875     def get_image_list(self, filter_dict={}):
 876         """Obtain tenant images from VIM
 877         Filter_dict can be:
 878             name: image name
 879             id: image uuid
 880             checksum: image checksum
 881             location: image path
 882         Returns the image list of dictionaries:
 883             [{<the fields at Filter_dict plus some VIM specific>}, ...]
 884             List can be empty
 885         """
 886         try:
 887             self._get_my_tenant()
 888             filterquery = []
 889             filterquery_text = ""
 890             for k, v in filter_dict.items():
 891                 filterquery.append(str(k) + "=" + str(v))
 892             if len(filterquery) > 0:
 893                 filterquery_text = "?" + "&".join(filterquery)
 894             url = self.url + "/" + self.tenant + "/images" + filterquery_text
 895             self.logger.info("Getting image list GET %s", url)
 896             vim_response = requests.get(url, headers=self.headers_req)
 897             self._check_http_request_response(vim_response)
 898             self.logger.debug(vim_response.text)
 899             # print json.dumps(vim_response.json(), indent=4)
 900             response = vim_response.json()
 901             return response["images"]
 902         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
 903             self._format_request_exception(e)
 904
 905     def new_vminstancefromJSON(self, vm_data):
 906         """Adds a VM instance to VIM"""
 907         """Returns the instance identifier"""
 908         try:
 909             self._get_my_tenant()
 910         except Exception as e:
 911             return -vimconn.HTTP_Not_Found, str(e)
 912         print("VIMConnector: Adding a new VM instance from JSON to VIM")
 913         payload_req = vm_data
 914         try:
 915             vim_response = requests.post(
 916                 self.url + "/" + self.tenant + "/servers",
 917                 headers=self.headers_req,
 918                 data=payload_req,
 919             )
 920         except requests.exceptions.RequestException as e:
 921             print("new_vminstancefromJSON Exception: ", e.args)
 922             return -vimconn.HTTP_Not_Found, str(e.args[0])
 923         # print vim_response
 924         # print vim_response.status_code
 925         if vim_response.status_code == 200:
 926             # print vim_response.json()
 927             # print json.dumps(vim_response.json(), indent=4)
 928             res, http_content = self._format_in(vim_response, new_image_response_schema)
 929             # print http_content
 930             if res:
 931                 r = self._remove_extra_items(http_content, new_image_response_schema)
 932                 if r is not None:
 933                     print("Warning: remove extra items ", r)
 934                 # print http_content
 935                 vminstance_id = http_content["server"]["id"]
 936                 print("Tenant image id: ", vminstance_id)
 937                 return vim_response.status_code, vminstance_id
 938             else:
 939                 return -vimconn.HTTP_Bad_Request, http_content
 940         else:
 941             # print vim_response.text
 942             jsonerror = self._format_jsonerror(vim_response)
 943             text = 'Error in VIM "{}": not possible to add new vm instance. HTTP Response: {}. Error: {}'.format(
 944                 self.url, vim_response.status_code, jsonerror
 945             )
 946             # print text
 947             return -vim_response.status_code, text
 948
 949     def new_vminstance(
 950         self,
 951         name,
 952         description,
 953         start,
 954         image_id,
 955         flavor_id,
 956         affinity_group_list,
 957         net_list,
 958         cloud_config=None,
 959         disk_list=None,
 960         availability_zone_index=None,
 961         availability_zone_list=None,
 962     ):
 963         """Adds a VM instance to VIM
 964         Params:
 965             start: indicates if VM must start or boot in pause mode. Ignored
 966             image_id,flavor_id: image and flavor uuid
 967             net_list: list of interfaces, each one is a dictionary with:
 968                 name:
 969                 net_id: network uuid to connect
 970                 vpci: virtual vcpi to assign
 971                 model: interface model, virtio, e1000, ...
 972                 mac_address:
 973                 use: 'data', 'bridge',  'mgmt'
 974                 type: 'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
 975                 vim_id: filled/added by this function
 976                 #TODO ip, security groups
 977         Returns a tuple with the instance identifier and created_items or raises an exception on error
 978             created_items can be None or a dictionary where this method can include key-values that will be passed to
 979             the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
 980             Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
 981             as not present.
 982         """
 983         self.logger.debug(
 984             "new_vminstance input: image='%s' flavor='%s' nics='%s'",
 985             image_id,
 986             flavor_id,
 987             str(net_list),
 988         )
 989         try:
 990             self._get_my_tenant()
 991             #            net_list = []
 992             #            for k,v in net_dict.items():
 993             #                print k,v
 994             #                net_list.append('{"name":"' + k + '", "uuid":"' + v + '"}')
 995             #            net_list_string = ', '.join(net_list)
 996             virtio_net_list = []
 997             for net in net_list:
 998                 if not net.get("net_id"):
 999                     continue
1000                 net_dict = {"uuid": net["net_id"]}
1001                 if net.get("type"):
1002                     if net["type"] == "SR-IOV":
1003                         net_dict["type"] = "VF"
1004                     elif net["type"] == "PCI-PASSTHROUGH":
1005                         net_dict["type"] = "PF"
1006                     else:
1007                         net_dict["type"] = net["type"]
1008                 if net.get("name"):
1009                     net_dict["name"] = net["name"]
1010                 if net.get("vpci"):
1011                     net_dict["vpci"] = net["vpci"]
1012                 if net.get("model"):
1013                     if net["model"] == "VIRTIO" or net["model"] == "paravirt":
1014                         net_dict["model"] = "virtio"
1015                     else:
1016                         net_dict["model"] = net["model"]
1017                 if net.get("mac_address"):
1018                     net_dict["mac_address"] = net["mac_address"]
1019                 if net.get("ip_address"):
1020                     net_dict["ip_address"] = net["ip_address"]
1021                 virtio_net_list.append(net_dict)
1022             payload_dict = {
1023                 "name": name[:64],
1024                 "description": description,
1025                 "imageRef": image_id,
1026                 "flavorRef": flavor_id,
1027                 "networks": virtio_net_list,
1028             }
1029             if start is not None:
1030                 payload_dict["start"] = start
1031             payload_req = json.dumps({"server": payload_dict})
1032             url = self.url + "/" + self.tenant + "/servers"
1033             self.logger.info("Adding a new vm POST %s DATA %s", url, payload_req)
1034             vim_response = requests.post(
1035                 url, headers=self.headers_req, data=payload_req
1036             )
1037             self._check_http_request_response(vim_response)
1038             self.logger.debug(vim_response.text)
1039             # print json.dumps(vim_response.json(), indent=4)
1040             response = vim_response.json()
1041             js_v(response, new_vminstance_response_schema)
1042             # r = self._remove_extra_items(response, new_vminstance_response_schema)
1043             # if r is not None:
1044             #    self.logger.warn("Warning: remove extra items %s", str(r))
1045             vminstance_id = response["server"]["id"]
1046
1047             # connect data plane interfaces to network
1048             for net in net_list:
1049                 if net["type"] == "virtual":
1050                     if not net.get("net_id"):
1051                         continue
1052                     for iface in response["server"]["networks"]:
1053                         if "name" in net:
1054                             if net["name"] == iface["name"]:
1055                                 net["vim_id"] = iface["iface_id"]
1056                                 break
1057                         elif "net_id" in net:
1058                             if net["net_id"] == iface["net_id"]:
1059                                 net["vim_id"] = iface["iface_id"]
1060                                 break
1061                 else:  # dataplane
1062                     for numa in response["server"].get("extended", {}).get("numas", ()):
1063                         for iface in numa.get("interfaces", ()):
1064                             if net["name"] == iface["name"]:
1065                                 net["vim_id"] = iface["iface_id"]
1066                                 # Code bellow is not needed, current openvim connect dataplane interfaces
1067                                 # if net.get("net_id"):
1068                                 # connect dataplane interface
1069                                 #    result, port_id = self.connect_port_network(iface['iface_id'], net["net_id"])
1070                                 #    if result < 0:
1071                                 #        error_text = "Error attaching port %s to network %s: %s." % (iface['iface_id']
1072                                 #        , net["net_id"], port_id)
1073                                 #        print "new_vminstance: " + error_text
1074                                 #        self.delete_vminstance(vminstance_id)
1075                                 #        return result, error_text
1076                                 break
1077
1078             return vminstance_id, None
1079         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
1080             self._format_request_exception(e)
1081
1082     def get_vminstance(self, vm_id):
1083         """Returns the VM instance information from VIM"""
1084         try:
1085             self._get_my_tenant()
1086             url = self.url + "/" + self.tenant + "/servers/" + vm_id
1087             self.logger.info("Getting vm GET %s", url)
1088             vim_response = requests.get(url, headers=self.headers_req)
1089             vim_response = requests.get(url, headers=self.headers_req)
1090             self._check_http_request_response(vim_response)
1091             self.logger.debug(vim_response.text)
1092             # print json.dumps(vim_response.json(), indent=4)
1093             response = vim_response.json()
1094             js_v(response, new_vminstance_response_schema)
1095             # r = self._remove_extra_items(response, new_vminstance_response_schema)
1096             # if r is not None:
1097             #    self.logger.warn("Warning: remove extra items %s", str(r))
1098             return response["server"]
1099         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
1100             self._format_request_exception(e)
1101
1102     def delete_vminstance(self, vm_id, created_items=None):
1103         """Removes a VM instance from VIM, returns the deleted vm_id"""
1104         try:
1105             self._get_my_tenant()
1106             url = self.url + "/" + self.tenant + "/servers/" + vm_id
1107             self.logger.info("Deleting VIM vm DELETE %s", url)
1108             vim_response = requests.delete(url, headers=self.headers_req)
1109             self._check_http_request_response(vim_response)
1110             # self.logger.debug(vim_response.text)
1111             # print json.dumps(vim_response.json(), indent=4)
1112             return vm_id
1113         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
1114             self._format_request_exception(e)
1115
1116     def refresh_vms_status(self, vm_list):
1117         """Refreshes the status of the virtual machines"""
1118         try:
1119             self._get_my_tenant()
1120         except requests.exceptions.RequestException as e:
1121             self._format_request_exception(e)
1122         vm_dict = {}
1123         for vm_id in vm_list:
1124             vm = {}
1125             # print "VIMConnector refresh_tenant_vms and nets: Getting tenant VM instance information from VIM"
1126             try:
1127                 url = self.url + "/" + self.tenant + "/servers/" + vm_id
1128                 self.logger.info("Getting vm GET %s", url)
1129                 vim_response = requests.get(url, headers=self.headers_req)
1130                 self._check_http_request_response(vim_response)
1131                 response = vim_response.json()
1132                 js_v(response, new_vminstance_response_schema)
1133                 if response["server"]["status"] in vmStatus2manoFormat:
1134                     vm["status"] = vmStatus2manoFormat[response["server"]["status"]]
1135                 else:
1136                     vm["status"] = "OTHER"
1137                     vm["error_msg"] = (
1138                         "VIM status reported " + response["server"]["status"]
1139                     )
1140                 if response["server"].get("last_error"):
1141                     vm["error_msg"] = response["server"]["last_error"]
1142                 vm["vim_info"] = yaml.safe_dump(response["server"])
1143                 # get interfaces info
1144                 try:
1145                     management_ip = False
1146                     url2 = self.url + "/ports?device_id=" + quote(vm_id)
1147                     self.logger.info("Getting PORTS GET %s", url2)
1148                     vim_response2 = requests.get(url2, headers=self.headers_req)
1149                     self._check_http_request_response(vim_response2)
1150                     client_data = vim_response2.json()
1151                     if isinstance(client_data.get("ports"), list):
1152                         vm["interfaces"] = []
1153                     for port in client_data.get("ports"):
1154                         interface = {}
1155                         interface["vim_info"] = yaml.safe_dump(port)
1156                         interface["mac_address"] = port.get("mac_address")
1157                         interface["vim_net_id"] = port.get("network_id")
1158                         interface["vim_interface_id"] = port["id"]
1159                         interface["ip_address"] = port.get("ip_address")
1160                         if interface["ip_address"]:
1161                             management_ip = True
1162                         if interface["ip_address"] == "0.0.0.0":
1163                             interface["ip_address"] = None
1164                         vm["interfaces"].append(interface)
1165
1166                 except Exception as e:
1167                     self.logger.error(
1168                         "refresh_vms_and_nets. Port get %s: %s",
1169                         type(e).__name__,
1170                         str(e),
1171                     )
1172
1173                 if vm["status"] == "ACTIVE" and not management_ip:
1174                     vm["status"] = "ACTIVE:NoMgmtIP"
1175
1176             except vimconn.VimConnNotFoundException as e:
1177                 self.logger.error("Exception getting vm status: %s", str(e))
1178                 vm["status"] = "DELETED"
1179                 vm["error_msg"] = str(e)
1180             except (
1181                 requests.exceptions.RequestException,
1182                 js_e.ValidationError,
1183                 vimconn.VimConnException,
1184             ) as e:
1185                 self.logger.error("Exception getting vm status: %s", str(e))
1186                 vm["status"] = "VIM_ERROR"
1187                 vm["error_msg"] = str(e)
1188             vm_dict[vm_id] = vm
1189         return vm_dict
1190
1191     def refresh_nets_status(self, net_list):
1192         """Get the status of the networks
1193         Params: the list of network identifiers
1194         Returns a dictionary with:
1195              net_id:         #VIM id of this network
1196                  status:     #Mandatory. Text with one of:
1197                              #  DELETED (not found at vim)
1198                              #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1199                              #  OTHER (Vim reported other status not understood)
1200                              #  ERROR (VIM indicates an ERROR status)
1201                              #  ACTIVE, INACTIVE, DOWN (admin down),
1202                              #  BUILD (on building process)
1203                              #
1204                  error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
1205                  vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
1206
1207         """
1208         try:
1209             self._get_my_tenant()
1210         except requests.exceptions.RequestException as e:
1211             self._format_request_exception(e)
1212
1213         net_dict = {}
1214         for net_id in net_list:
1215             net = {}
1216             # print "VIMConnector refresh_tenant_vms_and_nets:
1217             # Getting tenant network from VIM (tenant: " + str(self.tenant) + "): "
1218             try:
1219                 net_vim = self.get_network(net_id)
1220                 if net_vim["status"] in netStatus2manoFormat:
1221                     net["status"] = netStatus2manoFormat[net_vim["status"]]
1222                 else:
1223                     net["status"] = "OTHER"
1224                     net["error_msg"] = "VIM status reported " + net_vim["status"]
1225
1226                 if net["status"] == "ACTIVE" and not net_vim["admin_state_up"]:
1227                     net["status"] = "DOWN"
1228                 if net_vim.get("last_error"):
1229                     net["error_msg"] = net_vim["last_error"]
1230                 net["vim_info"] = yaml.safe_dump(net_vim)
1231             except vimconn.VimConnNotFoundException as e:
1232                 self.logger.error("Exception getting net status: %s", str(e))
1233                 net["status"] = "DELETED"
1234                 net["error_msg"] = str(e)
1235             except (
1236                 requests.exceptions.RequestException,
1237                 js_e.ValidationError,
1238                 vimconn.VimConnException,
1239             ) as e:
1240                 self.logger.error("Exception getting net status: %s", str(e))
1241                 net["status"] = "VIM_ERROR"
1242                 net["error_msg"] = str(e)
1243             net_dict[net_id] = net
1244         return net_dict
1245
1246     def action_vminstance(self, vm_id, action_dict, created_items={}):
1247         """Send and action over a VM instance from VIM"""
1248         """Returns the status"""
1249         try:
1250             self._get_my_tenant()
1251             if "console" in action_dict:
1252                 raise vimconn.VimConnException(
1253                     "getting console is not available at openvim",
1254                     http_code=vimconn.HTTP_Service_Unavailable,
1255                 )
1256             url = self.url + "/" + self.tenant + "/servers/" + vm_id + "/action"
1257             self.logger.info("Action over VM instance POST %s", url)
1258             vim_response = requests.post(
1259                 url, headers=self.headers_req, data=json.dumps(action_dict)
1260             )
1261             self._check_http_request_response(vim_response)
1262             return None
1263         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
1264             self._format_request_exception(e)
1265
1266     # NOT USED METHODS in current version
1267
1268     def host_vim2gui(self, host, server_dict):
1269         """Transform host dictionary from VIM format to GUI format,
1270         and append to the server_dict
1271         """
1272         if type(server_dict) is not dict:
1273             print(
1274                 "vimconnector.host_vim2gui() ERROR, param server_dict must be a dictionary"
1275             )
1276             return
1277         RAD = {}
1278         occupation = {}
1279         for numa in host["host"]["numas"]:
1280             RAD_item = {}
1281             occupation_item = {}
1282             # memory
1283             RAD_item["memory"] = {
1284                 "size": str(numa["memory"]) + "GB",
1285                 "eligible": str(numa["hugepages"]) + "GB",
1286             }
1287             occupation_item["memory"] = str(numa["hugepages_consumed"]) + "GB"
1288             # cpus
1289             RAD_item["cpus"] = {}
1290             RAD_item["cpus"]["cores"] = []
1291             RAD_item["cpus"]["eligible_cores"] = []
1292             occupation_item["cores"] = []
1293             for _ in range(0, len(numa["cores"]) // 2):
1294                 RAD_item["cpus"]["cores"].append([])
1295             for core in numa["cores"]:
1296                 RAD_item["cpus"]["cores"][core["core_id"]].append(core["thread_id"])
1297                 if "status" not in core:
1298                     RAD_item["cpus"]["eligible_cores"].append(core["thread_id"])
1299                 if "instance_id" in core:
1300                     occupation_item["cores"].append(core["thread_id"])
1301             # ports
1302             RAD_item["ports"] = {}
1303             occupation_item["ports"] = {}
1304             for iface in numa["interfaces"]:
1305                 RAD_item["ports"][iface["pci"]] = "speed:" + str(iface["Mbps"]) + "M"
1306                 occupation_item["ports"][iface["pci"]] = {
1307                     "occupied": str(100 * iface["Mbps_consumed"] // iface["Mbps"]) + "%"
1308                 }
1309
1310             RAD[numa["numa_socket"]] = RAD_item
1311             occupation[numa["numa_socket"]] = occupation_item
1312         server_dict[host["host"]["name"]] = {"RAD": RAD, "occupation": occupation}
1313
1314     def get_hosts_info(self):
1315         """Get the information of deployed hosts
1316         Returns the hosts content"""
1317         # obtain hosts list
1318         url = self.url + "/hosts"
1319         try:
1320             vim_response = requests.get(url)
1321         except requests.exceptions.RequestException as e:
1322             print("get_hosts_info Exception: ", e.args)
1323             return -vimconn.HTTP_Not_Found, str(e.args[0])
1324         print(
1325             "vim get", url, "response:", vim_response.status_code, vim_response.json()
1326         )
1327         # print vim_response.status_code
1328         # print json.dumps(vim_response.json(), indent=4)
1329         if vim_response.status_code != 200:
1330             # TODO: get error
1331             print(
1332                 "vimconnector.get_hosts_info error getting host list {} {}".format(
1333                     vim_response.status_code, vim_response.json()
1334                 )
1335             )
1336             return -vim_response.status_code, "Error getting host list"
1337
1338         res, hosts = self._format_in(vim_response, get_hosts_response_schema)
1339
1340         if not res:
1341             print(
1342                 "vimconnector.get_hosts_info error parsing GET HOSTS vim response",
1343                 hosts,
1344             )
1345             return vimconn.HTTP_Internal_Server_Error, hosts
1346         # obtain hosts details
1347         hosts_dict = {}
1348         for host in hosts["hosts"]:
1349             url = self.url + "/hosts/" + host["id"]
1350             try:
1351                 vim_response = requests.get(url)
1352             except requests.exceptions.RequestException as e:
1353                 print("get_hosts_info Exception: ", e.args)
1354                 return -vimconn.HTTP_Not_Found, str(e.args[0])
1355             print(
1356                 "vim get",
1357                 url,
1358                 "response:",
1359                 vim_response.status_code,
1360                 vim_response.json(),
1361             )
1362             if vim_response.status_code != 200:
1363                 print(
1364                     "vimconnector.get_hosts_info error getting detailed host {} {}".format(
1365                         vim_response.status_code, vim_response.json()
1366                     )
1367                 )
1368                 continue
1369             res, host_detail = self._format_in(
1370                 vim_response, get_host_detail_response_schema
1371             )
1372             if not res:
1373                 print(
1374                     "vimconnector.get_hosts_info error parsing GET HOSTS/{} vim response {}".format(
1375                         host["id"], host_detail
1376                     ),
1377                 )
1378                 continue
1379             # print 'host id '+host['id'], json.dumps(host_detail, indent=4)
1380             self.host_vim2gui(host_detail, hosts_dict)
1381         return 200, hosts_dict
1382
1383     def get_hosts(self, vim_tenant):
1384         """Get the hosts and deployed instances
1385         Returns the hosts content"""
1386         # obtain hosts list
1387         url = self.url + "/hosts"
1388         try:
1389             vim_response = requests.get(url)
1390         except requests.exceptions.RequestException as e:
1391             print("get_hosts Exception: ", e.args)
1392             return -vimconn.HTTP_Not_Found, str(e.args[0])
1393         print(
1394             "vim get", url, "response:", vim_response.status_code, vim_response.json()
1395         )
1396         # print vim_response.status_code
1397         # print json.dumps(vim_response.json(), indent=4)
1398         if vim_response.status_code != 200:
1399             # TODO: get error
1400             print(
1401                 "vimconnector.get_hosts error getting host list {} {}".format(
1402                     vim_response.status_code, vim_response.json()
1403                 )
1404             )
1405             return -vim_response.status_code, "Error getting host list"
1406
1407         res, hosts = self._format_in(vim_response, get_hosts_response_schema)
1408
1409         if not res:
1410             print("vimconnector.get_host error parsing GET HOSTS vim response", hosts)
1411             return vimconn.HTTP_Internal_Server_Error, hosts
1412         # obtain instances from hosts
1413         for host in hosts["hosts"]:
1414             url = self.url + "/" + vim_tenant + "/servers?hostId=" + host["id"]
1415             try:
1416                 vim_response = requests.get(url)
1417             except requests.exceptions.RequestException as e:
1418                 print("get_hosts Exception: ", e.args)
1419                 return -vimconn.HTTP_Not_Found, str(e.args[0])
1420             print(
1421                 "vim get",
1422                 url,
1423                 "response:",
1424                 vim_response.status_code,
1425                 vim_response.json(),
1426             )
1427             if vim_response.status_code != 200:
1428                 print(
1429                     "vimconnector.get_hosts error getting instances at host {} {}".format(
1430                         vim_response.status_code, vim_response.json()
1431                     )
1432                 )
1433                 continue
1434             res, servers = self._format_in(vim_response, get_server_response_schema)
1435             if not res:
1436                 print(
1437                     "vimconnector.get_host error parsing GET SERVERS/{} vim response {}".format(
1438                         host["id"], servers
1439                     ),
1440                 )
1441                 continue
1442             # print 'host id '+host['id'], json.dumps(host_detail, indent=4)
1443             host["instances"] = servers["servers"]
1444         return 200, hosts["hosts"]
1445
1446     def get_processor_rankings(self):
1447         """Get the processor rankings in the VIM database"""
1448         url = self.url + "/processor_ranking"
1449         try:
1450             vim_response = requests.get(url)
1451         except requests.exceptions.RequestException as e:
1452             print("get_processor_rankings Exception: ", e.args)
1453             return -vimconn.HTTP_Not_Found, str(e.args[0])
1454         print(
1455             "vim get", url, "response:", vim_response.status_code, vim_response.json()
1456         )
1457         # print vim_response.status_code
1458         # print json.dumps(vim_response.json(), indent=4)
1459         if vim_response.status_code != 200:
1460             # TODO: get error
1461             print(
1462                 "vimconnector.get_processor_rankings error getting processor rankings {} {}".format(
1463                     vim_response.status_code, vim_response.json()
1464                 )
1465             )
1466             return -vim_response.status_code, "Error getting processor rankings"
1467
1468         res, rankings = self._format_in(
1469             vim_response, get_processor_rankings_response_schema
1470         )
1471         return res, rankings["rankings"]
1472
1473     def new_host(self, host_data):
1474         """Adds a new host to VIM"""
1475         """Returns status code of the VIM response"""
1476         payload_req = host_data
1477         try:
1478             url = self.url_admin + "/hosts"
1479             self.logger.info("Adding a new host POST %s", url)
1480             vim_response = requests.post(
1481                 url, headers=self.headers_req, data=payload_req
1482             )
1483             self._check_http_request_response(vim_response)
1484             self.logger.debug(vim_response.text)
1485             # print json.dumps(vim_response.json(), indent=4)
1486             response = vim_response.json()
1487             js_v(response, new_host_response_schema)
1488             r = self._remove_extra_items(response, new_host_response_schema)
1489             if r is not None:
1490                 self.logger.warn("Warning: remove extra items %s", str(r))
1491             host_id = response["host"]["id"]
1492             return host_id
1493         except (requests.exceptions.RequestException, js_e.ValidationError) as e:
1494             self._format_request_exception(e)
1495
1496     def new_external_port(self, port_data):
1497         """Adds a external port to VIM"""
1498         """Returns the port identifier"""
1499         # TODO change to logging exception code policies
1500         print("VIMConnector: Adding a new external port")
1501         payload_req = port_data
1502         try:
1503             vim_response = requests.post(
1504                 self.url_admin + "/ports", headers=self.headers_req, data=payload_req
1505             )
1506         except requests.exceptions.RequestException as e:
1507             self.logger.error("new_external_port Exception: ", str(e))
1508             return -vimconn.HTTP_Not_Found, str(e.args[0])
1509         print(vim_response)
1510         # print vim_response.status_code
1511         if vim_response.status_code == 200:
1512             # print vim_response.json()
1513             # print json.dumps(vim_response.json(), indent=4)
1514             res, http_content = self._format_in(vim_response, new_port_response_schema)
1515             # print http_content
1516             if res:
1517                 r = self._remove_extra_items(http_content, new_port_response_schema)
1518                 if r is not None:
1519                     print("Warning: remove extra items ", r)
1520                 # print http_content
1521                 port_id = http_content["port"]["id"]
1522                 print("Port id: ", port_id)
1523                 return vim_response.status_code, port_id
1524             else:
1525                 return -vimconn.HTTP_Bad_Request, http_content
1526         else:
1527             # print vim_response.text
1528             jsonerror = self._format_jsonerror(vim_response)
1529             text = 'Error in VIM "{}": not possible to add new external port. HTTP Response: {}. Error: {}'.format(
1530                 self.url_admin, vim_response.status_code, jsonerror
1531             )
1532             # print text
1533             return -vim_response.status_code, text
1534
1535     def new_external_network(self, net_name, net_type):
1536         """Adds a external network to VIM (shared)"""
1537         """Returns the network identifier"""
1538         # TODO change to logging exception code policies
1539         print(
1540             "VIMConnector: Adding external shared network to VIM (type "
1541             + net_type
1542             + "): "
1543             + net_name
1544         )
1545
1546         payload_req = (
1547             '{"network":{"name": "'
1548             + net_name
1549             + '","shared":true,"type": "'
1550             + net_type
1551             + '"}}'
1552         )
1553         try:
1554             vim_response = requests.post(
1555                 self.url + "/networks", headers=self.headers_req, data=payload_req
1556             )
1557         except requests.exceptions.RequestException as e:
1558             self.logger.error("new_external_network Exception: ", e.args)
1559             return -vimconn.HTTP_Not_Found, str(e.args[0])
1560         print(vim_response)
1561         # print vim_response.status_code
1562         if vim_response.status_code == 200:
1563             # print vim_response.json()
1564             # print json.dumps(vim_response.json(), indent=4)
1565             res, http_content = self._format_in(
1566                 vim_response, new_network_response_schema
1567             )
1568             # print http_content
1569             if res:
1570                 r = self._remove_extra_items(http_content, new_network_response_schema)
1571                 if r is not None:
1572                     print("Warning: remove extra items ", r)
1573                 # print http_content
1574                 network_id = http_content["network"]["id"]
1575                 print("Network id: ", network_id)
1576                 return vim_response.status_code, network_id
1577             else:
1578                 return -vimconn.HTTP_Bad_Request, http_content
1579         else:
1580             # print vim_response.text
1581             jsonerror = self._format_jsonerror(vim_response)
1582             text = 'Error in VIM "{}": not possible to add new external network. HTTP Response: {}. Error: {}'.format(
1583                 self.url, vim_response.status_code, jsonerror
1584             )
1585             # print text
1586             return -vim_response.status_code, text
1587
1588     def connect_port_network(self, port_id, network_id, admin=False):
1589         """Connects a external port to a network"""
1590         """Returns status code of the VIM response"""
1591         # TODO change to logging exception code policies
1592         print("VIMConnector: Connecting external port to network")
1593
1594         payload_req = '{"port":{"network_id":"' + network_id + '"}}'
1595         if admin:
1596             if self.url_admin is None:
1597                 return (
1598                     -vimconn.HTTP_Unauthorized,
1599                     "datacenter cannot contain  admin URL",
1600                 )
1601             url = self.url_admin
1602         else:
1603             url = self.url
1604         try:
1605             vim_response = requests.put(
1606                 url + "/ports/" + port_id, headers=self.headers_req, data=payload_req
1607             )
1608         except requests.exceptions.RequestException as e:
1609             print("connect_port_network Exception: ", e.args)
1610             return -vimconn.HTTP_Not_Found, str(e.args[0])
1611         print(vim_response)
1612         # print vim_response.status_code
1613         if vim_response.status_code == 200:
1614             # print vim_response.json()
1615             # print json.dumps(vim_response.json(), indent=4)
1616             res, http_content = self._format_in(vim_response, new_port_response_schema)
1617             # print http_content
1618             if res:
1619                 r = self._remove_extra_items(http_content, new_port_response_schema)
1620                 if r is not None:
1621                     print("Warning: remove extra items ", r)
1622                 # print http_content
1623                 port_id = http_content["port"]["id"]
1624                 print("Port id: ", port_id)
1625                 return vim_response.status_code, port_id
1626             else:
1627                 return -vimconn.HTTP_Bad_Request, http_content
1628         else:
1629             print(vim_response.text)
1630             jsonerror = self._format_jsonerror(vim_response)
1631             text = (
1632                 'Error in VIM "{}": not possible to connect external port to network. HTTP Response: {}.'
1633                 " Error: {}".format(self.url_admin, vim_response.status_code, jsonerror)
1634             )
1635             print(text)
1636             return -vim_response.status_code, text
1637
1638     def migrate_instance(self, vm_id, compute_host=None):
1639         """
1640         Migrate a vdu
1641         param:
1642             vm_id: ID of an instance
1643             compute_host: Host to migrate the vdu to
1644         """
1645         # TODO: Add support for migration
1646         raise vimconn.VimConnNotImplemented("Not implemented")
1647
1648     def resize_instance(self, vm_id, flavor_id=None):
1649         """
1650         resize a vdu
1651         param:
1652             vm_id: ID of an instance
1653             flavor_id: flavor_id to resize the vdu to
1654         """
1655         # TODO: Add support for resize
1656         raise vimconn.VimConnNotImplemented("Not implemented")