RO-VIM-openstack/osm_rovim_openstack/vimconn_openstack.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
  21 """
  22 osconnector implements all the methods to interact with openstack using the python-neutronclient.
  23
  24 For the VNF forwarding graph, The OpenStack VIM connector calls the
  25 networking-sfc Neutron extension methods, whose resources are mapped
  26 to the VIM connector's SFC resources as follows:
  27 - Classification (OSM) -> Flow Classifier (Neutron)
  28 - Service Function Instance (OSM) -> Port Pair (Neutron)
  29 - Service Function (OSM) -> Port Pair Group (Neutron)
  30 - Service Function Path (OSM) -> Port Chain (Neutron)
  31 """
  32
  33 import copy
  34 from http.client import HTTPException
  35 import json
  36 import logging
  37 from pprint import pformat
  38 import random
  39 import re
  40 import time
  41 from typing import Dict, List, Optional, Tuple
  42
  43 from cinderclient import client as cClient
  44 from glanceclient import client as glClient
  45 import glanceclient.exc as gl1Exceptions
  46 from keystoneauth1 import session
  47 from keystoneauth1.identity import v2, v3
  48 import keystoneclient.exceptions as ksExceptions
  49 import keystoneclient.v2_0.client as ksClient_v2
  50 import keystoneclient.v3.client as ksClient_v3
  51 import netaddr
  52 from neutronclient.common import exceptions as neExceptions
  53 from neutronclient.neutron import client as neClient
  54 from novaclient import client as nClient, exceptions as nvExceptions
  55 from osm_ro_plugin import vimconn
  56 from requests.exceptions import ConnectionError
  57 import yaml
  58
  59 __author__ = "Alfonso Tierno, Gerardo Garcia, Pablo Montes, xFlow Research, Igor D.C., Eduardo Sousa"
  60 __date__ = "$22-sep-2017 23:59:59$"
  61
  62 """contain the openstack virtual machine status to openmano status"""
  63 vmStatus2manoFormat = {
  64     "ACTIVE": "ACTIVE",
  65     "PAUSED": "PAUSED",
  66     "SUSPENDED": "SUSPENDED",
  67     "SHUTOFF": "INACTIVE",
  68     "BUILD": "BUILD",
  69     "ERROR": "ERROR",
  70     "DELETED": "DELETED",
  71 }
  72 netStatus2manoFormat = {
  73     "ACTIVE": "ACTIVE",
  74     "PAUSED": "PAUSED",
  75     "INACTIVE": "INACTIVE",
  76     "BUILD": "BUILD",
  77     "ERROR": "ERROR",
  78     "DELETED": "DELETED",
  79 }
  80
  81 supportedClassificationTypes = ["legacy_flow_classifier"]
  82
  83 # global var to have a timeout creating and deleting volumes
  84 volume_timeout = 1800
  85 server_timeout = 1800
  86
  87
  88 class SafeDumper(yaml.SafeDumper):
  89     def represent_data(self, data):
  90         # Openstack APIs use custom subclasses of dict and YAML safe dumper
  91         # is designed to not handle that (reference issue 142 of pyyaml)
  92         if isinstance(data, dict) and data.__class__ != dict:
  93             # A simple solution is to convert those items back to dicts
  94             data = dict(data.items())
  95
  96         return super(SafeDumper, self).represent_data(data)
  97
  98
  99 class vimconnector(vimconn.VimConnector):
 100     def __init__(
 101         self,
 102         uuid,
 103         name,
 104         tenant_id,
 105         tenant_name,
 106         url,
 107         url_admin=None,
 108         user=None,
 109         passwd=None,
 110         log_level=None,
 111         config={},
 112         persistent_info={},
 113     ):
 114         """using common constructor parameters. In this case
 115         'url' is the keystone authorization url,
 116         'url_admin' is not use
 117         """
 118         api_version = config.get("APIversion")
 119
 120         if api_version and api_version not in ("v3.3", "v2.0", "2", "3"):
 121             raise vimconn.VimConnException(
 122                 "Invalid value '{}' for config:APIversion. "
 123                 "Allowed values are 'v3.3', 'v2.0', '2' or '3'".format(api_version)
 124             )
 125
 126         vim_type = config.get("vim_type")
 127
 128         if vim_type and vim_type not in ("vio", "VIO"):
 129             raise vimconn.VimConnException(
 130                 "Invalid value '{}' for config:vim_type."
 131                 "Allowed values are 'vio' or 'VIO'".format(vim_type)
 132             )
 133
 134         if config.get("dataplane_net_vlan_range") is not None:
 135             # validate vlan ranges provided by user
 136             self._validate_vlan_ranges(
 137                 config.get("dataplane_net_vlan_range"), "dataplane_net_vlan_range"
 138             )
 139
 140         if config.get("multisegment_vlan_range") is not None:
 141             # validate vlan ranges provided by user
 142             self._validate_vlan_ranges(
 143                 config.get("multisegment_vlan_range"), "multisegment_vlan_range"
 144             )
 145
 146         vimconn.VimConnector.__init__(
 147             self,
 148             uuid,
 149             name,
 150             tenant_id,
 151             tenant_name,
 152             url,
 153             url_admin,
 154             user,
 155             passwd,
 156             log_level,
 157             config,
 158         )
 159
 160         if self.config.get("insecure") and self.config.get("ca_cert"):
 161             raise vimconn.VimConnException(
 162                 "options insecure and ca_cert are mutually exclusive"
 163             )
 164
 165         self.verify = True
 166
 167         if self.config.get("insecure"):
 168             self.verify = False
 169
 170         if self.config.get("ca_cert"):
 171             self.verify = self.config.get("ca_cert")
 172
 173         if not url:
 174             raise TypeError("url param can not be NoneType")
 175
 176         self.persistent_info = persistent_info
 177         self.availability_zone = persistent_info.get("availability_zone", None)
 178         self.session = persistent_info.get("session", {"reload_client": True})
 179         self.my_tenant_id = self.session.get("my_tenant_id")
 180         self.nova = self.session.get("nova")
 181         self.neutron = self.session.get("neutron")
 182         self.cinder = self.session.get("cinder")
 183         self.glance = self.session.get("glance")
 184         # self.glancev1 = self.session.get("glancev1")
 185         self.keystone = self.session.get("keystone")
 186         self.api_version3 = self.session.get("api_version3")
 187         self.vim_type = self.config.get("vim_type")
 188
 189         if self.vim_type:
 190             self.vim_type = self.vim_type.upper()
 191
 192         if self.config.get("use_internal_endpoint"):
 193             self.endpoint_type = "internalURL"
 194         else:
 195             self.endpoint_type = None
 196
 197         logging.getLogger("urllib3").setLevel(logging.WARNING)
 198         logging.getLogger("keystoneauth").setLevel(logging.WARNING)
 199         logging.getLogger("novaclient").setLevel(logging.WARNING)
 200         self.logger = logging.getLogger("ro.vim.openstack")
 201
 202         # allow security_groups to be a list or a single string
 203         if isinstance(self.config.get("security_groups"), str):
 204             self.config["security_groups"] = [self.config["security_groups"]]
 205
 206         self.security_groups_id = None
 207
 208         # ###### VIO Specific Changes #########
 209         if self.vim_type == "VIO":
 210             self.logger = logging.getLogger("ro.vim.vio")
 211
 212         if log_level:
 213             self.logger.setLevel(getattr(logging, log_level))
 214
 215     def __getitem__(self, index):
 216         """Get individuals parameters.
 217         Throw KeyError"""
 218         if index == "project_domain_id":
 219             return self.config.get("project_domain_id")
 220         elif index == "user_domain_id":
 221             return self.config.get("user_domain_id")
 222         else:
 223             return vimconn.VimConnector.__getitem__(self, index)
 224
 225     def __setitem__(self, index, value):
 226         """Set individuals parameters and it is marked as dirty so to force connection reload.
 227         Throw KeyError"""
 228         if index == "project_domain_id":
 229             self.config["project_domain_id"] = value
 230         elif index == "user_domain_id":
 231             self.config["user_domain_id"] = value
 232         else:
 233             vimconn.VimConnector.__setitem__(self, index, value)
 234
 235         self.session["reload_client"] = True
 236
 237     def serialize(self, value):
 238         """Serialization of python basic types.
 239
 240         In the case value is not serializable a message will be logged and a
 241         simple representation of the data that cannot be converted back to
 242         python is returned.
 243         """
 244         if isinstance(value, str):
 245             return value
 246
 247         try:
 248             return yaml.dump(
 249                 value, Dumper=SafeDumper, default_flow_style=True, width=256
 250             )
 251         except yaml.representer.RepresenterError:
 252             self.logger.debug(
 253                 "The following entity cannot be serialized in YAML:\n\n%s\n\n",
 254                 pformat(value),
 255                 exc_info=True,
 256             )
 257
 258             return str(value)
 259
 260     def _reload_connection(self):
 261         """Called before any operation, it check if credentials has changed
 262         Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
 263         """
 264         # TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
 265         if self.session["reload_client"]:
 266             if self.config.get("APIversion"):
 267                 self.api_version3 = (
 268                     self.config["APIversion"] == "v3.3"
 269                     or self.config["APIversion"] == "3"
 270                 )
 271             else:  # get from ending auth_url that end with v3 or with v2.0
 272                 self.api_version3 = self.url.endswith("/v3") or self.url.endswith(
 273                     "/v3/"
 274                 )
 275
 276             self.session["api_version3"] = self.api_version3
 277
 278             if self.api_version3:
 279                 if self.config.get("project_domain_id") or self.config.get(
 280                     "project_domain_name"
 281                 ):
 282                     project_domain_id_default = None
 283                 else:
 284                     project_domain_id_default = "default"
 285
 286                 if self.config.get("user_domain_id") or self.config.get(
 287                     "user_domain_name"
 288                 ):
 289                     user_domain_id_default = None
 290                 else:
 291                     user_domain_id_default = "default"
 292                 auth = v3.Password(
 293                     auth_url=self.url,
 294                     username=self.user,
 295                     password=self.passwd,
 296                     project_name=self.tenant_name,
 297                     project_id=self.tenant_id,
 298                     project_domain_id=self.config.get(
 299                         "project_domain_id", project_domain_id_default
 300                     ),
 301                     user_domain_id=self.config.get(
 302                         "user_domain_id", user_domain_id_default
 303                     ),
 304                     project_domain_name=self.config.get("project_domain_name"),
 305                     user_domain_name=self.config.get("user_domain_name"),
 306                 )
 307             else:
 308                 auth = v2.Password(
 309                     auth_url=self.url,
 310                     username=self.user,
 311                     password=self.passwd,
 312                     tenant_name=self.tenant_name,
 313                     tenant_id=self.tenant_id,
 314                 )
 315
 316             sess = session.Session(auth=auth, verify=self.verify)
 317             # addedd region_name to keystone, nova, neutron and cinder to support distributed cloud for Wind River
 318             # Titanium cloud and StarlingX
 319             region_name = self.config.get("region_name")
 320
 321             if self.api_version3:
 322                 self.keystone = ksClient_v3.Client(
 323                     session=sess,
 324                     endpoint_type=self.endpoint_type,
 325                     region_name=region_name,
 326                 )
 327             else:
 328                 self.keystone = ksClient_v2.Client(
 329                     session=sess, endpoint_type=self.endpoint_type
 330                 )
 331
 332             self.session["keystone"] = self.keystone
 333             # In order to enable microversion functionality an explicit microversion must be specified in "config".
 334             # This implementation approach is due to the warning message in
 335             # https://developer.openstack.org/api-guide/compute/microversions.html
 336             # where it is stated that microversion backwards compatibility is not guaranteed and clients should
 337             # always require an specific microversion.
 338             # To be able to use "device role tagging" functionality define "microversion: 2.32" in datacenter config
 339             version = self.config.get("microversion")
 340
 341             if not version:
 342                 version = "2.1"
 343
 344             # addedd region_name to keystone, nova, neutron and cinder to support distributed cloud for Wind River
 345             # Titanium cloud and StarlingX
 346             self.nova = self.session["nova"] = nClient.Client(
 347                 str(version),
 348                 session=sess,
 349                 endpoint_type=self.endpoint_type,
 350                 region_name=region_name,
 351             )
 352             self.neutron = self.session["neutron"] = neClient.Client(
 353                 "2.0",
 354                 session=sess,
 355                 endpoint_type=self.endpoint_type,
 356                 region_name=region_name,
 357             )
 358             self.cinder = self.session["cinder"] = cClient.Client(
 359                 2,
 360                 session=sess,
 361                 endpoint_type=self.endpoint_type,
 362                 region_name=region_name,
 363             )
 364
 365             try:
 366                 self.my_tenant_id = self.session["my_tenant_id"] = sess.get_project_id()
 367             except Exception:
 368                 self.logger.error("Cannot get project_id from session", exc_info=True)
 369
 370             if self.endpoint_type == "internalURL":
 371                 glance_service_id = self.keystone.services.list(name="glance")[0].id
 372                 glance_endpoint = self.keystone.endpoints.list(
 373                     glance_service_id, interface="internal"
 374                 )[0].url
 375             else:
 376                 glance_endpoint = None
 377
 378             self.glance = self.session["glance"] = glClient.Client(
 379                 2, session=sess, endpoint=glance_endpoint
 380             )
 381             # using version 1 of glance client in new_image()
 382             # self.glancev1 = self.session["glancev1"] = glClient.Client("1", session=sess,
 383             #                                                            endpoint=glance_endpoint)
 384             self.session["reload_client"] = False
 385             self.persistent_info["session"] = self.session
 386             # add availablity zone info inside  self.persistent_info
 387             self._set_availablity_zones()
 388             self.persistent_info["availability_zone"] = self.availability_zone
 389             # force to get again security_groups_ids next time they are needed
 390             self.security_groups_id = None
 391
 392     def __net_os2mano(self, net_list_dict):
 393         """Transform the net openstack format to mano format
 394         net_list_dict can be a list of dict or a single dict"""
 395         if type(net_list_dict) is dict:
 396             net_list_ = (net_list_dict,)
 397         elif type(net_list_dict) is list:
 398             net_list_ = net_list_dict
 399         else:
 400             raise TypeError("param net_list_dict must be a list or a dictionary")
 401         for net in net_list_:
 402             if net.get("provider:network_type") == "vlan":
 403                 net["type"] = "data"
 404             else:
 405                 net["type"] = "bridge"
 406
 407     def __classification_os2mano(self, class_list_dict):
 408         """Transform the openstack format (Flow Classifier) to mano format
 409         (Classification) class_list_dict can be a list of dict or a single dict
 410         """
 411         if isinstance(class_list_dict, dict):
 412             class_list_ = [class_list_dict]
 413         elif isinstance(class_list_dict, list):
 414             class_list_ = class_list_dict
 415         else:
 416             raise TypeError("param class_list_dict must be a list or a dictionary")
 417         for classification in class_list_:
 418             id = classification.pop("id")
 419             name = classification.pop("name")
 420             description = classification.pop("description")
 421             project_id = classification.pop("project_id")
 422             tenant_id = classification.pop("tenant_id")
 423             original_classification = copy.deepcopy(classification)
 424             classification.clear()
 425             classification["ctype"] = "legacy_flow_classifier"
 426             classification["definition"] = original_classification
 427             classification["id"] = id
 428             classification["name"] = name
 429             classification["description"] = description
 430             classification["project_id"] = project_id
 431             classification["tenant_id"] = tenant_id
 432
 433     def __sfi_os2mano(self, sfi_list_dict):
 434         """Transform the openstack format (Port Pair) to mano format (SFI)
 435         sfi_list_dict can be a list of dict or a single dict
 436         """
 437         if isinstance(sfi_list_dict, dict):
 438             sfi_list_ = [sfi_list_dict]
 439         elif isinstance(sfi_list_dict, list):
 440             sfi_list_ = sfi_list_dict
 441         else:
 442             raise TypeError("param sfi_list_dict must be a list or a dictionary")
 443
 444         for sfi in sfi_list_:
 445             sfi["ingress_ports"] = []
 446             sfi["egress_ports"] = []
 447
 448             if sfi.get("ingress"):
 449                 sfi["ingress_ports"].append(sfi["ingress"])
 450
 451             if sfi.get("egress"):
 452                 sfi["egress_ports"].append(sfi["egress"])
 453
 454             del sfi["ingress"]
 455             del sfi["egress"]
 456             params = sfi.get("service_function_parameters")
 457             sfc_encap = False
 458
 459             if params:
 460                 correlation = params.get("correlation")
 461
 462                 if correlation:
 463                     sfc_encap = True
 464
 465             sfi["sfc_encap"] = sfc_encap
 466             del sfi["service_function_parameters"]
 467
 468     def __sf_os2mano(self, sf_list_dict):
 469         """Transform the openstack format (Port Pair Group) to mano format (SF)
 470         sf_list_dict can be a list of dict or a single dict
 471         """
 472         if isinstance(sf_list_dict, dict):
 473             sf_list_ = [sf_list_dict]
 474         elif isinstance(sf_list_dict, list):
 475             sf_list_ = sf_list_dict
 476         else:
 477             raise TypeError("param sf_list_dict must be a list or a dictionary")
 478
 479         for sf in sf_list_:
 480             del sf["port_pair_group_parameters"]
 481             sf["sfis"] = sf["port_pairs"]
 482             del sf["port_pairs"]
 483
 484     def __sfp_os2mano(self, sfp_list_dict):
 485         """Transform the openstack format (Port Chain) to mano format (SFP)
 486         sfp_list_dict can be a list of dict or a single dict
 487         """
 488         if isinstance(sfp_list_dict, dict):
 489             sfp_list_ = [sfp_list_dict]
 490         elif isinstance(sfp_list_dict, list):
 491             sfp_list_ = sfp_list_dict
 492         else:
 493             raise TypeError("param sfp_list_dict must be a list or a dictionary")
 494
 495         for sfp in sfp_list_:
 496             params = sfp.pop("chain_parameters")
 497             sfc_encap = False
 498
 499             if params:
 500                 correlation = params.get("correlation")
 501
 502                 if correlation:
 503                     sfc_encap = True
 504
 505             sfp["sfc_encap"] = sfc_encap
 506             sfp["spi"] = sfp.pop("chain_id")
 507             sfp["classifications"] = sfp.pop("flow_classifiers")
 508             sfp["service_functions"] = sfp.pop("port_pair_groups")
 509
 510     # placeholder for now; read TODO note below
 511     def _validate_classification(self, type, definition):
 512         # only legacy_flow_classifier Type is supported at this point
 513         return True
 514         # TODO(igordcard): this method should be an abstract method of an
 515         # abstract Classification class to be implemented by the specific
 516         # Types. Also, abstract vimconnector should call the validation
 517         # method before the implemented VIM connectors are called.
 518
 519     def _format_exception(self, exception):
 520         """Transform a keystone, nova, neutron  exception into a vimconn exception discovering the cause"""
 521         message_error = str(exception)
 522         tip = ""
 523
 524         if isinstance(
 525             exception,
 526             (
 527                 neExceptions.NetworkNotFoundClient,
 528                 nvExceptions.NotFound,
 529                 ksExceptions.NotFound,
 530                 gl1Exceptions.HTTPNotFound,
 531             ),
 532         ):
 533             raise vimconn.VimConnNotFoundException(
 534                 type(exception).__name__ + ": " + message_error
 535             )
 536         elif isinstance(
 537             exception,
 538             (
 539                 HTTPException,
 540                 gl1Exceptions.HTTPException,
 541                 gl1Exceptions.CommunicationError,
 542                 ConnectionError,
 543                 ksExceptions.ConnectionError,
 544                 neExceptions.ConnectionFailed,
 545             ),
 546         ):
 547             if type(exception).__name__ == "SSLError":
 548                 tip = " (maybe option 'insecure' must be added to the VIM)"
 549
 550             raise vimconn.VimConnConnectionException(
 551                 "Invalid URL or credentials{}: {}".format(tip, message_error)
 552             )
 553         elif isinstance(
 554             exception,
 555             (
 556                 KeyError,
 557                 nvExceptions.BadRequest,
 558                 ksExceptions.BadRequest,
 559             ),
 560         ):
 561             raise vimconn.VimConnException(
 562                 type(exception).__name__ + ": " + message_error
 563             )
 564         elif isinstance(
 565             exception,
 566             (
 567                 nvExceptions.ClientException,
 568                 ksExceptions.ClientException,
 569                 neExceptions.NeutronException,
 570             ),
 571         ):
 572             raise vimconn.VimConnUnexpectedResponse(
 573                 type(exception).__name__ + ": " + message_error
 574             )
 575         elif isinstance(exception, nvExceptions.Conflict):
 576             raise vimconn.VimConnConflictException(
 577                 type(exception).__name__ + ": " + message_error
 578             )
 579         elif isinstance(exception, vimconn.VimConnException):
 580             raise exception
 581         else:  # ()
 582             self.logger.error("General Exception " + message_error, exc_info=True)
 583
 584             raise vimconn.VimConnConnectionException(
 585                 type(exception).__name__ + ": " + message_error
 586             )
 587
 588     def _get_ids_from_name(self):
 589         """
 590          Obtain ids from name of tenant and security_groups. Store at self .security_groups_id"
 591         :return: None
 592         """
 593         # get tenant_id if only tenant_name is supplied
 594         self._reload_connection()
 595
 596         if not self.my_tenant_id:
 597             raise vimconn.VimConnConnectionException(
 598                 "Error getting tenant information from name={} id={}".format(
 599                     self.tenant_name, self.tenant_id
 600                 )
 601             )
 602
 603         if self.config.get("security_groups") and not self.security_groups_id:
 604             # convert from name to id
 605             neutron_sg_list = self.neutron.list_security_groups(
 606                 tenant_id=self.my_tenant_id
 607             )["security_groups"]
 608
 609             self.security_groups_id = []
 610             for sg in self.config.get("security_groups"):
 611                 for neutron_sg in neutron_sg_list:
 612                     if sg in (neutron_sg["id"], neutron_sg["name"]):
 613                         self.security_groups_id.append(neutron_sg["id"])
 614                         break
 615                 else:
 616                     self.security_groups_id = None
 617
 618                     raise vimconn.VimConnConnectionException(
 619                         "Not found security group {} for this tenant".format(sg)
 620                     )
 621
 622     def check_vim_connectivity(self):
 623         # just get network list to check connectivity and credentials
 624         self.get_network_list(filter_dict={})
 625
 626     def get_tenant_list(self, filter_dict={}):
 627         """Obtain tenants of VIM
 628         filter_dict can contain the following keys:
 629             name: filter by tenant name
 630             id: filter by tenant uuid/id
 631             <other VIM specific>
 632         Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
 633         """
 634         self.logger.debug("Getting tenants from VIM filter: '%s'", str(filter_dict))
 635
 636         try:
 637             self._reload_connection()
 638
 639             if self.api_version3:
 640                 project_class_list = self.keystone.projects.list(
 641                     name=filter_dict.get("name")
 642                 )
 643             else:
 644                 project_class_list = self.keystone.tenants.findall(**filter_dict)
 645
 646             project_list = []
 647
 648             for project in project_class_list:
 649                 if filter_dict.get("id") and filter_dict["id"] != project.id:
 650                     continue
 651
 652                 project_list.append(project.to_dict())
 653
 654             return project_list
 655         except (
 656             ksExceptions.ConnectionError,
 657             ksExceptions.ClientException,
 658             ConnectionError,
 659         ) as e:
 660             self._format_exception(e)
 661
 662     def new_tenant(self, tenant_name, tenant_description):
 663         """Adds a new tenant to openstack VIM. Returns the tenant identifier"""
 664         self.logger.debug("Adding a new tenant name: %s", tenant_name)
 665
 666         try:
 667             self._reload_connection()
 668
 669             if self.api_version3:
 670                 project = self.keystone.projects.create(
 671                     tenant_name,
 672                     self.config.get("project_domain_id", "default"),
 673                     description=tenant_description,
 674                     is_domain=False,
 675                 )
 676             else:
 677                 project = self.keystone.tenants.create(tenant_name, tenant_description)
 678
 679             return project.id
 680         except (
 681             ksExceptions.ConnectionError,
 682             ksExceptions.ClientException,
 683             ksExceptions.BadRequest,
 684             ConnectionError,
 685         ) as e:
 686             self._format_exception(e)
 687
 688     def delete_tenant(self, tenant_id):
 689         """Delete a tenant from openstack VIM. Returns the old tenant identifier"""
 690         self.logger.debug("Deleting tenant %s from VIM", tenant_id)
 691
 692         try:
 693             self._reload_connection()
 694
 695             if self.api_version3:
 696                 self.keystone.projects.delete(tenant_id)
 697             else:
 698                 self.keystone.tenants.delete(tenant_id)
 699
 700             return tenant_id
 701         except (
 702             ksExceptions.ConnectionError,
 703             ksExceptions.ClientException,
 704             ksExceptions.NotFound,
 705             ConnectionError,
 706         ) as e:
 707             self._format_exception(e)
 708
 709     def new_network(
 710         self,
 711         net_name,
 712         net_type,
 713         ip_profile=None,
 714         shared=False,
 715         provider_network_profile=None,
 716     ):
 717         """Adds a tenant network to VIM
 718         Params:
 719             'net_name': name of the network
 720             'net_type': one of:
 721                 'bridge': overlay isolated network
 722                 'data':   underlay E-LAN network for Passthrough and SRIOV interfaces
 723                 'ptp':    underlay E-LINE network for Passthrough and SRIOV interfaces.
 724             'ip_profile': is a dict containing the IP parameters of the network
 725                 'ip_version': can be "IPv4" or "IPv6" (Currently only IPv4 is implemented)
 726                 'subnet_address': ip_prefix_schema, that is X.X.X.X/Y
 727                 'gateway_address': (Optional) ip_schema, that is X.X.X.X
 728                 'dns_address': (Optional) comma separated list of ip_schema, e.g. X.X.X.X[,X,X,X,X]
 729                 'dhcp_enabled': True or False
 730                 'dhcp_start_address': ip_schema, first IP to grant
 731                 'dhcp_count': number of IPs to grant.
 732             'shared': if this network can be seen/use by other tenants/organization
 733             'provider_network_profile': (optional) contains {segmentation-id: vlan, network-type: vlan|vxlan,
 734                                                              physical-network: physnet-label}
 735         Returns a tuple with the network identifier and created_items, or raises an exception on error
 736             created_items can be None or a dictionary where this method can include key-values that will be passed to
 737             the method delete_network. Can be used to store created segments, created l2gw connections, etc.
 738             Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
 739             as not present.
 740         """
 741         self.logger.debug(
 742             "Adding a new network to VIM name '%s', type '%s'", net_name, net_type
 743         )
 744         # self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
 745
 746         try:
 747             vlan = None
 748
 749             if provider_network_profile:
 750                 vlan = provider_network_profile.get("segmentation-id")
 751
 752             new_net = None
 753             created_items = {}
 754             self._reload_connection()
 755             network_dict = {"name": net_name, "admin_state_up": True}
 756
 757             if net_type in ("data", "ptp") or provider_network_profile:
 758                 provider_physical_network = None
 759
 760                 if provider_network_profile and provider_network_profile.get(
 761                     "physical-network"
 762                 ):
 763                     provider_physical_network = provider_network_profile.get(
 764                         "physical-network"
 765                     )
 766
 767                     # provider-network must be one of the dataplane_physcial_netowrk if this is a list. If it is string
 768                     # or not declared, just ignore the checking
 769                     if (
 770                         isinstance(
 771                             self.config.get("dataplane_physical_net"), (tuple, list)
 772                         )
 773                         and provider_physical_network
 774                         not in self.config["dataplane_physical_net"]
 775                     ):
 776                         raise vimconn.VimConnConflictException(
 777                             "Invalid parameter 'provider-network:physical-network' "
 778                             "for network creation. '{}' is not one of the declared "
 779                             "list at VIM_config:dataplane_physical_net".format(
 780                                 provider_physical_network
 781                             )
 782                         )
 783
 784                 # use the default dataplane_physical_net
 785                 if not provider_physical_network:
 786                     provider_physical_network = self.config.get(
 787                         "dataplane_physical_net"
 788                     )
 789
 790                     # if it is non empty list, use the first value. If it is a string use the value directly
 791                     if (
 792                         isinstance(provider_physical_network, (tuple, list))
 793                         and provider_physical_network
 794                     ):
 795                         provider_physical_network = provider_physical_network[0]
 796
 797                 if not provider_physical_network:
 798                     raise vimconn.VimConnConflictException(
 799                         "missing information needed for underlay networks. Provide "
 800                         "'dataplane_physical_net' configuration at VIM or use the NS "
 801                         "instantiation parameter 'provider-network.physical-network'"
 802                         " for the VLD"
 803                     )
 804
 805                 if not self.config.get("multisegment_support"):
 806                     network_dict[
 807                         "provider:physical_network"
 808                     ] = provider_physical_network
 809
 810                     if (
 811                         provider_network_profile
 812                         and "network-type" in provider_network_profile
 813                     ):
 814                         network_dict[
 815                             "provider:network_type"
 816                         ] = provider_network_profile["network-type"]
 817                     else:
 818                         network_dict["provider:network_type"] = self.config.get(
 819                             "dataplane_network_type", "vlan"
 820                         )
 821
 822                     if vlan:
 823                         network_dict["provider:segmentation_id"] = vlan
 824                 else:
 825                     # Multi-segment case
 826                     segment_list = []
 827                     segment1_dict = {
 828                         "provider:physical_network": "",
 829                         "provider:network_type": "vxlan",
 830                     }
 831                     segment_list.append(segment1_dict)
 832                     segment2_dict = {
 833                         "provider:physical_network": provider_physical_network,
 834                         "provider:network_type": "vlan",
 835                     }
 836
 837                     if vlan:
 838                         segment2_dict["provider:segmentation_id"] = vlan
 839                     elif self.config.get("multisegment_vlan_range"):
 840                         vlanID = self._generate_multisegment_vlanID()
 841                         segment2_dict["provider:segmentation_id"] = vlanID
 842
 843                     # else
 844                     #     raise vimconn.VimConnConflictException(
 845                     #         "You must provide "multisegment_vlan_range" at config dict before creating a multisegment
 846                     #         network")
 847                     segment_list.append(segment2_dict)
 848                     network_dict["segments"] = segment_list
 849
 850                 # VIO Specific Changes. It needs a concrete VLAN
 851                 if self.vim_type == "VIO" and vlan is None:
 852                     if self.config.get("dataplane_net_vlan_range") is None:
 853                         raise vimconn.VimConnConflictException(
 854                             "You must provide 'dataplane_net_vlan_range' in format "
 855                             "[start_ID - end_ID] at VIM_config for creating underlay "
 856                             "networks"
 857                         )
 858
 859                     network_dict["provider:segmentation_id"] = self._generate_vlanID()
 860
 861             network_dict["shared"] = shared
 862
 863             if self.config.get("disable_network_port_security"):
 864                 network_dict["port_security_enabled"] = False
 865
 866             if self.config.get("neutron_availability_zone_hints"):
 867                 hints = self.config.get("neutron_availability_zone_hints")
 868
 869                 if isinstance(hints, str):
 870                     hints = [hints]
 871
 872                 network_dict["availability_zone_hints"] = hints
 873
 874             new_net = self.neutron.create_network({"network": network_dict})
 875             # print new_net
 876             # create subnetwork, even if there is no profile
 877
 878             if not ip_profile:
 879                 ip_profile = {}
 880
 881             if not ip_profile.get("subnet_address"):
 882                 # Fake subnet is required
 883                 subnet_rand = random.randint(0, 255)
 884                 ip_profile["subnet_address"] = "192.168.{}.0/24".format(subnet_rand)
 885
 886             if "ip_version" not in ip_profile:
 887                 ip_profile["ip_version"] = "IPv4"
 888
 889             subnet = {
 890                 "name": net_name + "-subnet",
 891                 "network_id": new_net["network"]["id"],
 892                 "ip_version": 4 if ip_profile["ip_version"] == "IPv4" else 6,
 893                 "cidr": ip_profile["subnet_address"],
 894             }
 895
 896             # Gateway should be set to None if not needed. Otherwise openstack assigns one by default
 897             if ip_profile.get("gateway_address"):
 898                 subnet["gateway_ip"] = ip_profile["gateway_address"]
 899             else:
 900                 subnet["gateway_ip"] = None
 901
 902             if ip_profile.get("dns_address"):
 903                 subnet["dns_nameservers"] = ip_profile["dns_address"].split(";")
 904
 905             if "dhcp_enabled" in ip_profile:
 906                 subnet["enable_dhcp"] = (
 907                     False
 908                     if ip_profile["dhcp_enabled"] == "false"
 909                     or ip_profile["dhcp_enabled"] is False
 910                     else True
 911                 )
 912
 913             if ip_profile.get("dhcp_start_address"):
 914                 subnet["allocation_pools"] = []
 915                 subnet["allocation_pools"].append(dict())
 916                 subnet["allocation_pools"][0]["start"] = ip_profile[
 917                     "dhcp_start_address"
 918                 ]
 919
 920             if ip_profile.get("dhcp_count"):
 921                 # parts = ip_profile["dhcp_start_address"].split(".")
 922                 # ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
 923                 ip_int = int(netaddr.IPAddress(ip_profile["dhcp_start_address"]))
 924                 ip_int += ip_profile["dhcp_count"] - 1
 925                 ip_str = str(netaddr.IPAddress(ip_int))
 926                 subnet["allocation_pools"][0]["end"] = ip_str
 927
 928             # self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
 929             self.neutron.create_subnet({"subnet": subnet})
 930
 931             if net_type == "data" and self.config.get("multisegment_support"):
 932                 if self.config.get("l2gw_support"):
 933                     l2gw_list = self.neutron.list_l2_gateways().get("l2_gateways", ())
 934                     for l2gw in l2gw_list:
 935                         l2gw_conn = {
 936                             "l2_gateway_id": l2gw["id"],
 937                             "network_id": new_net["network"]["id"],
 938                             "segmentation_id": str(vlanID),
 939                         }
 940                         new_l2gw_conn = self.neutron.create_l2_gateway_connection(
 941                             {"l2_gateway_connection": l2gw_conn}
 942                         )
 943                         created_items[
 944                             "l2gwconn:"
 945                             + str(new_l2gw_conn["l2_gateway_connection"]["id"])
 946                         ] = True
 947
 948             return new_net["network"]["id"], created_items
 949         except Exception as e:
 950             # delete l2gw connections (if any) before deleting the network
 951             for k, v in created_items.items():
 952                 if not v:  # skip already deleted
 953                     continue
 954
 955                 try:
 956                     k_item, _, k_id = k.partition(":")
 957
 958                     if k_item == "l2gwconn":
 959                         self.neutron.delete_l2_gateway_connection(k_id)
 960                 except Exception as e2:
 961                     self.logger.error(
 962                         "Error deleting l2 gateway connection: {}: {}".format(
 963                             type(e2).__name__, e2
 964                         )
 965                     )
 966
 967             if new_net:
 968                 self.neutron.delete_network(new_net["network"]["id"])
 969
 970             self._format_exception(e)
 971
 972     def get_network_list(self, filter_dict={}):
 973         """Obtain tenant networks of VIM
 974         Filter_dict can be:
 975             name: network name
 976             id: network uuid
 977             shared: boolean
 978             tenant_id: tenant
 979             admin_state_up: boolean
 980             status: 'ACTIVE'
 981         Returns the network list of dictionaries
 982         """
 983         self.logger.debug("Getting network from VIM filter: '%s'", str(filter_dict))
 984
 985         try:
 986             self._reload_connection()
 987             filter_dict_os = filter_dict.copy()
 988
 989             if self.api_version3 and "tenant_id" in filter_dict_os:
 990                 # TODO check
 991                 filter_dict_os["project_id"] = filter_dict_os.pop("tenant_id")
 992
 993             net_dict = self.neutron.list_networks(**filter_dict_os)
 994             net_list = net_dict["networks"]
 995             self.__net_os2mano(net_list)
 996
 997             return net_list
 998         except (
 999             neExceptions.ConnectionFailed,
1000             ksExceptions.ClientException,
1001             neExceptions.NeutronException,
1002             ConnectionError,
1003         ) as e:
1004             self._format_exception(e)
1005
1006     def get_network(self, net_id):
1007         """Obtain details of network from VIM
1008         Returns the network information from a network id"""
1009         self.logger.debug(" Getting tenant network %s from VIM", net_id)
1010         filter_dict = {"id": net_id}
1011         net_list = self.get_network_list(filter_dict)
1012
1013         if len(net_list) == 0:
1014             raise vimconn.VimConnNotFoundException(
1015                 "Network '{}' not found".format(net_id)
1016             )
1017         elif len(net_list) > 1:
1018             raise vimconn.VimConnConflictException(
1019                 "Found more than one network with this criteria"
1020             )
1021
1022         net = net_list[0]
1023         subnets = []
1024         for subnet_id in net.get("subnets", ()):
1025             try:
1026                 subnet = self.neutron.show_subnet(subnet_id)
1027             except Exception as e:
1028                 self.logger.error(
1029                     "osconnector.get_network(): Error getting subnet %s %s"
1030                     % (net_id, str(e))
1031                 )
1032                 subnet = {"id": subnet_id, "fault": str(e)}
1033
1034             subnets.append(subnet)
1035
1036         net["subnets"] = subnets
1037         net["encapsulation"] = net.get("provider:network_type")
1038         net["encapsulation_type"] = net.get("provider:network_type")
1039         net["segmentation_id"] = net.get("provider:segmentation_id")
1040         net["encapsulation_id"] = net.get("provider:segmentation_id")
1041
1042         return net
1043
1044     def delete_network(self, net_id, created_items=None):
1045         """
1046         Removes a tenant network from VIM and its associated elements
1047         :param net_id: VIM identifier of the network, provided by method new_network
1048         :param created_items: dictionary with extra items to be deleted. provided by method new_network
1049         Returns the network identifier or raises an exception upon error or when network is not found
1050         """
1051         self.logger.debug("Deleting network '%s' from VIM", net_id)
1052
1053         if created_items is None:
1054             created_items = {}
1055
1056         try:
1057             self._reload_connection()
1058             # delete l2gw connections (if any) before deleting the network
1059             for k, v in created_items.items():
1060                 if not v:  # skip already deleted
1061                     continue
1062
1063                 try:
1064                     k_item, _, k_id = k.partition(":")
1065                     if k_item == "l2gwconn":
1066                         self.neutron.delete_l2_gateway_connection(k_id)
1067                 except Exception as e:
1068                     self.logger.error(
1069                         "Error deleting l2 gateway connection: {}: {}".format(
1070                             type(e).__name__, e
1071                         )
1072                     )
1073
1074             # delete VM ports attached to this networks before the network
1075             ports = self.neutron.list_ports(network_id=net_id)
1076             for p in ports["ports"]:
1077                 try:
1078                     self.neutron.delete_port(p["id"])
1079                 except Exception as e:
1080                     self.logger.error("Error deleting port %s: %s", p["id"], str(e))
1081
1082             self.neutron.delete_network(net_id)
1083
1084             return net_id
1085         except (
1086             neExceptions.ConnectionFailed,
1087             neExceptions.NetworkNotFoundClient,
1088             neExceptions.NeutronException,
1089             ksExceptions.ClientException,
1090             neExceptions.NeutronException,
1091             ConnectionError,
1092         ) as e:
1093             self._format_exception(e)
1094
1095     def refresh_nets_status(self, net_list):
1096         """Get the status of the networks
1097         Params: the list of network identifiers
1098         Returns a dictionary with:
1099             net_id:         #VIM id of this network
1100                 status:     #Mandatory. Text with one of:
1101                             #  DELETED (not found at vim)
1102                             #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1103                             #  OTHER (Vim reported other status not understood)
1104                             #  ERROR (VIM indicates an ERROR status)
1105                             #  ACTIVE, INACTIVE, DOWN (admin down),
1106                             #  BUILD (on building process)
1107                             #
1108                 error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
1109                 vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
1110         """
1111         net_dict = {}
1112
1113         for net_id in net_list:
1114             net = {}
1115
1116             try:
1117                 net_vim = self.get_network(net_id)
1118
1119                 if net_vim["status"] in netStatus2manoFormat:
1120                     net["status"] = netStatus2manoFormat[net_vim["status"]]
1121                 else:
1122                     net["status"] = "OTHER"
1123                     net["error_msg"] = "VIM status reported " + net_vim["status"]
1124
1125                 if net["status"] == "ACTIVE" and not net_vim["admin_state_up"]:
1126                     net["status"] = "DOWN"
1127
1128                 net["vim_info"] = self.serialize(net_vim)
1129
1130                 if net_vim.get("fault"):  # TODO
1131                     net["error_msg"] = str(net_vim["fault"])
1132             except vimconn.VimConnNotFoundException as e:
1133                 self.logger.error("Exception getting net status: %s", str(e))
1134                 net["status"] = "DELETED"
1135                 net["error_msg"] = str(e)
1136             except vimconn.VimConnException as e:
1137                 self.logger.error("Exception getting net status: %s", str(e))
1138                 net["status"] = "VIM_ERROR"
1139                 net["error_msg"] = str(e)
1140             net_dict[net_id] = net
1141         return net_dict
1142
1143     def get_flavor(self, flavor_id):
1144         """Obtain flavor details from the  VIM. Returns the flavor dict details"""
1145         self.logger.debug("Getting flavor '%s'", flavor_id)
1146
1147         try:
1148             self._reload_connection()
1149             flavor = self.nova.flavors.find(id=flavor_id)
1150             # TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
1151
1152             return flavor.to_dict()
1153         except (
1154             nvExceptions.NotFound,
1155             nvExceptions.ClientException,
1156             ksExceptions.ClientException,
1157             ConnectionError,
1158         ) as e:
1159             self._format_exception(e)
1160
1161     def get_flavor_id_from_data(self, flavor_dict):
1162         """Obtain flavor id that match the flavor description
1163         Returns the flavor_id or raises a vimconnNotFoundException
1164         flavor_dict: contains the required ram, vcpus, disk
1165         If 'use_existing_flavors' is set to True at config, the closer flavor that provides same or more ram, vcpus
1166             and disk is returned. Otherwise a flavor with exactly same ram, vcpus and disk is returned or a
1167             vimconnNotFoundException is raised
1168         """
1169         exact_match = False if self.config.get("use_existing_flavors") else True
1170
1171         try:
1172             self._reload_connection()
1173             flavor_candidate_id = None
1174             flavor_candidate_data = (10000, 10000, 10000)
1175             flavor_target = (
1176                 flavor_dict["ram"],
1177                 flavor_dict["vcpus"],
1178                 flavor_dict["disk"],
1179                 flavor_dict.get("ephemeral", 0),
1180                 flavor_dict.get("swap", 0),
1181             )
1182             # numa=None
1183             extended = flavor_dict.get("extended", {})
1184             if extended:
1185                 # TODO
1186                 raise vimconn.VimConnNotFoundException(
1187                     "Flavor with EPA still not implemented"
1188                 )
1189                 # if len(numas) > 1:
1190                 #     raise vimconn.VimConnNotFoundException("Cannot find any flavor with more than one numa")
1191                 # numa=numas[0]
1192                 # numas = extended.get("numas")
1193             for flavor in self.nova.flavors.list():
1194                 epa = flavor.get_keys()
1195
1196                 if epa:
1197                     continue
1198                     # TODO
1199
1200                 flavor_data = (
1201                     flavor.ram,
1202                     flavor.vcpus,
1203                     flavor.disk,
1204                     flavor.ephemeral,
1205                     flavor.swap if isinstance(flavor.swap, int) else 0,
1206                 )
1207                 if flavor_data == flavor_target:
1208                     return flavor.id
1209                 elif (
1210                     not exact_match
1211                     and flavor_target < flavor_data < flavor_candidate_data
1212                 ):
1213                     flavor_candidate_id = flavor.id
1214                     flavor_candidate_data = flavor_data
1215
1216             if not exact_match and flavor_candidate_id:
1217                 return flavor_candidate_id
1218
1219             raise vimconn.VimConnNotFoundException(
1220                 "Cannot find any flavor matching '{}'".format(flavor_dict)
1221             )
1222         except (
1223             nvExceptions.NotFound,
1224             nvExceptions.ClientException,
1225             ksExceptions.ClientException,
1226             ConnectionError,
1227         ) as e:
1228             self._format_exception(e)
1229
1230     @staticmethod
1231     def process_resource_quota(quota: dict, prefix: str, extra_specs: dict) -> None:
1232         """Process resource quota and fill up extra_specs.
1233         Args:
1234             quota       (dict):         Keeping the quota of resurces
1235             prefix      (str)           Prefix
1236             extra_specs (dict)          Dict to be filled to be used during flavor creation
1237
1238         """
1239         if "limit" in quota:
1240             extra_specs["quota:" + prefix + "_limit"] = quota["limit"]
1241
1242         if "reserve" in quota:
1243             extra_specs["quota:" + prefix + "_reservation"] = quota["reserve"]
1244
1245         if "shares" in quota:
1246             extra_specs["quota:" + prefix + "_shares_level"] = "custom"
1247             extra_specs["quota:" + prefix + "_shares_share"] = quota["shares"]
1248
1249     @staticmethod
1250     def process_numa_memory(
1251         numa: dict, node_id: Optional[int], extra_specs: dict
1252     ) -> None:
1253         """Set the memory in extra_specs.
1254         Args:
1255             numa        (dict):         A dictionary which includes numa information
1256             node_id     (int):          ID of numa node
1257             extra_specs (dict):         To be filled.
1258
1259         """
1260         if not numa.get("memory"):
1261             return
1262         memory_mb = numa["memory"] * 1024
1263         memory = "hw:numa_mem.{}".format(node_id)
1264         extra_specs[memory] = int(memory_mb)
1265
1266     @staticmethod
1267     def process_numa_vcpu(numa: dict, node_id: int, extra_specs: dict) -> None:
1268         """Set the cpu in extra_specs.
1269         Args:
1270             numa        (dict):         A dictionary which includes numa information
1271             node_id     (int):          ID of numa node
1272             extra_specs (dict):         To be filled.
1273
1274         """
1275         if not numa.get("vcpu"):
1276             return
1277         vcpu = numa["vcpu"]
1278         cpu = "hw:numa_cpus.{}".format(node_id)
1279         vcpu = ",".join(map(str, vcpu))
1280         extra_specs[cpu] = vcpu
1281
1282     @staticmethod
1283     def process_numa_paired_threads(numa: dict, extra_specs: dict) -> Optional[int]:
1284         """Fill up extra_specs if numa has paired-threads.
1285         Args:
1286             numa        (dict):         A dictionary which includes numa information
1287             extra_specs (dict):         To be filled.
1288
1289         Returns:
1290             vcpus       (int)           Number of virtual cpus
1291
1292         """
1293         if not numa.get("paired-threads"):
1294             return
1295         # cpu_thread_policy "require" implies that compute node must have an STM architecture
1296         vcpus = numa["paired-threads"] * 2
1297         extra_specs["hw:cpu_thread_policy"] = "require"
1298         extra_specs["hw:cpu_policy"] = "dedicated"
1299         return vcpus
1300
1301     @staticmethod
1302     def process_numa_cores(numa: dict, extra_specs: dict) -> Optional[int]:
1303         """Fill up extra_specs if numa has cores.
1304         Args:
1305             numa        (dict):         A dictionary which includes numa information
1306             extra_specs (dict):         To be filled.
1307
1308         Returns:
1309             vcpus       (int)           Number of virtual cpus
1310
1311         """
1312         # cpu_thread_policy "isolate" implies that the host must not have an SMT
1313         # architecture, or a non-SMT architecture will be emulated
1314         if not numa.get("cores"):
1315             return
1316         vcpus = numa["cores"]
1317         extra_specs["hw:cpu_thread_policy"] = "isolate"
1318         extra_specs["hw:cpu_policy"] = "dedicated"
1319         return vcpus
1320
1321     @staticmethod
1322     def process_numa_threads(numa: dict, extra_specs: dict) -> Optional[int]:
1323         """Fill up extra_specs if numa has threads.
1324         Args:
1325             numa        (dict):         A dictionary which includes numa information
1326             extra_specs (dict):         To be filled.
1327
1328         Returns:
1329             vcpus       (int)           Number of virtual cpus
1330
1331         """
1332         # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
1333         if not numa.get("threads"):
1334             return
1335         vcpus = numa["threads"]
1336         extra_specs["hw:cpu_thread_policy"] = "prefer"
1337         extra_specs["hw:cpu_policy"] = "dedicated"
1338         return vcpus
1339
1340     def _process_numa_parameters_of_flavor(
1341         self, numas: List, extra_specs: Dict, vcpus: Optional[int]
1342     ) -> int:
1343         """Process numa parameters and fill up extra_specs.
1344
1345         Args:
1346             numas   (list):             List of dictionary which includes numa information
1347             extra_specs (dict):         To be filled.
1348             vcpus       (int)      Number of virtual cpus
1349
1350         Returns:
1351             vcpus       (int)           Number of virtual cpus
1352
1353         """
1354         numa_nodes = len(numas)
1355         extra_specs["hw:numa_nodes"] = str(numa_nodes)
1356
1357         if self.vim_type == "VIO":
1358             extra_specs["vmware:extra_config"] = '{"numa.nodeAffinity":"0"}'
1359             extra_specs["vmware:latency_sensitivity_level"] = "high"
1360
1361         for numa in numas:
1362             if "id" in numa:
1363                 node_id = numa["id"]
1364                 # overwrite ram and vcpus
1365                 # check if key "memory" is present in numa else use ram value at flavor
1366                 self.process_numa_memory(numa, node_id, extra_specs)
1367                 self.process_numa_vcpu(numa, node_id, extra_specs)
1368
1369             # See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
1370             extra_specs["hw:cpu_sockets"] = str(numa_nodes)
1371
1372             if "paired-threads" in numa:
1373                 vcpus = self.process_numa_paired_threads(numa, extra_specs)
1374
1375             elif "cores" in numa:
1376                 vcpus = self.process_numa_cores(numa, extra_specs)
1377
1378             elif "threads" in numa:
1379                 vcpus = self.process_numa_threads(numa, extra_specs)
1380
1381         return vcpus
1382
1383     def _change_flavor_name(
1384         self, name: str, name_suffix: int, flavor_data: dict
1385     ) -> str:
1386         """Change the flavor name if the name already exists.
1387
1388         Args:
1389             name    (str):          Flavor name to be checked
1390             name_suffix (int):      Suffix to be appended to name
1391             flavor_data (dict):     Flavor dict
1392
1393         Returns:
1394             name    (str):          New flavor name to be used
1395
1396         """
1397         # Get used names
1398         fl = self.nova.flavors.list()
1399         fl_names = [f.name for f in fl]
1400
1401         while name in fl_names:
1402             name_suffix += 1
1403             name = flavor_data["name"] + "-" + str(name_suffix)
1404
1405         return name
1406
1407     def _process_extended_config_of_flavor(
1408         self, extended: dict, extra_specs: dict, vcpus: Optional[int]
1409     ) -> int:
1410         """Process the extended dict to fill up extra_specs.
1411         Args:
1412
1413             extended    (dict):         Keeping the extra specification of flavor
1414             extra_specs (dict)          Dict to be filled to be used during flavor creation
1415             vcpus       (int)           Number of virtual cpus
1416
1417         Returns:
1418             vcpus       (int)           Number of virtual cpus
1419
1420         """
1421         quotas = {
1422             "cpu-quota": "cpu",
1423             "mem-quota": "memory",
1424             "vif-quota": "vif",
1425             "disk-io-quota": "disk_io",
1426         }
1427
1428         page_sizes = {
1429             "LARGE": "large",
1430             "SMALL": "small",
1431             "SIZE_2MB": "2MB",
1432             "SIZE_1GB": "1GB",
1433             "PREFER_LARGE": "any",
1434         }
1435
1436         policies = {
1437             "cpu-pinning-policy": "hw:cpu_policy",
1438             "cpu-thread-pinning-policy": "hw:cpu_thread_policy",
1439             "mem-policy": "hw:numa_mempolicy",
1440         }
1441
1442         numas = extended.get("numas")
1443         if numas:
1444             vcpus = self._process_numa_parameters_of_flavor(numas, extra_specs, vcpus)
1445
1446         for quota, item in quotas.items():
1447             if quota in extended.keys():
1448                 self.process_resource_quota(extended.get(quota), item, extra_specs)
1449
1450         # Set the mempage size as specified in the descriptor
1451         if extended.get("mempage-size"):
1452             if extended["mempage-size"] in page_sizes.keys():
1453                 extra_specs["hw:mem_page_size"] = page_sizes[extended["mempage-size"]]
1454             else:
1455                 # Normally, validations in NBI should not allow to this condition.
1456                 self.logger.debug(
1457                     "Invalid mempage-size %s. Will be ignored",
1458                     extended.get("mempage-size"),
1459                 )
1460
1461         for policy, hw_policy in policies.items():
1462             if extended.get(policy):
1463                 extra_specs[hw_policy] = extended[policy].lower()
1464
1465         return vcpus
1466
1467     @staticmethod
1468     def _get_flavor_details(flavor_data: dict) -> Tuple:
1469         """Returns the details of flavor
1470         Args:
1471             flavor_data     (dict):     Dictionary that includes required flavor details
1472
1473         Returns:
1474             ram, vcpus, extra_specs, extended   (tuple):    Main items of required flavor
1475
1476         """
1477         return (
1478             flavor_data.get("ram", 64),
1479             flavor_data.get("vcpus", 1),
1480             {},
1481             flavor_data.get("extended"),
1482         )
1483
1484     def new_flavor(self, flavor_data: dict, change_name_if_used: bool = True) -> str:
1485         """Adds a tenant flavor to openstack VIM.
1486         if change_name_if_used is True, it will change name in case of conflict,
1487         because it is not supported name repetition.
1488
1489         Args:
1490             flavor_data (dict):             Flavor details to be processed
1491             change_name_if_used (bool):     Change name in case of conflict
1492
1493         Returns:
1494              flavor_id  (str):     flavor identifier
1495
1496         """
1497         self.logger.debug("Adding flavor '%s'", str(flavor_data))
1498         retry = 0
1499         max_retries = 3
1500         name_suffix = 0
1501
1502         try:
1503             name = flavor_data["name"]
1504             while retry < max_retries:
1505                 retry += 1
1506                 try:
1507                     self._reload_connection()
1508
1509                     if change_name_if_used:
1510                         name = self._change_flavor_name(name, name_suffix, flavor_data)
1511
1512                     ram, vcpus, extra_specs, extended = self._get_flavor_details(
1513                         flavor_data
1514                     )
1515                     if extended:
1516                         vcpus = self._process_extended_config_of_flavor(
1517                             extended, extra_specs, vcpus
1518                         )
1519
1520                     # Create flavor
1521
1522                     new_flavor = self.nova.flavors.create(
1523                         name=name,
1524                         ram=ram,
1525                         vcpus=vcpus,
1526                         disk=flavor_data.get("disk", 0),
1527                         ephemeral=flavor_data.get("ephemeral", 0),
1528                         swap=flavor_data.get("swap", 0),
1529                         is_public=flavor_data.get("is_public", True),
1530                     )
1531
1532                     # Add metadata
1533                     if extra_specs:
1534                         new_flavor.set_keys(extra_specs)
1535
1536                     return new_flavor.id
1537
1538                 except nvExceptions.Conflict as e:
1539                     if change_name_if_used and retry < max_retries:
1540                         continue
1541
1542                     self._format_exception(e)
1543
1544         except (
1545             ksExceptions.ClientException,
1546             nvExceptions.ClientException,
1547             ConnectionError,
1548             KeyError,
1549         ) as e:
1550             self._format_exception(e)
1551
1552     def delete_flavor(self, flavor_id):
1553         """Deletes a tenant flavor from openstack VIM. Returns the old flavor_id"""
1554         try:
1555             self._reload_connection()
1556             self.nova.flavors.delete(flavor_id)
1557
1558             return flavor_id
1559         # except nvExceptions.BadRequest as e:
1560         except (
1561             nvExceptions.NotFound,
1562             ksExceptions.ClientException,
1563             nvExceptions.ClientException,
1564             ConnectionError,
1565         ) as e:
1566             self._format_exception(e)
1567
1568     def new_image(self, image_dict):
1569         """
1570         Adds a tenant image to VIM. imge_dict is a dictionary with:
1571             name: name
1572             disk_format: qcow2, vhd, vmdk, raw (by default), ...
1573             location: path or URI
1574             public: "yes" or "no"
1575             metadata: metadata of the image
1576         Returns the image_id
1577         """
1578         retry = 0
1579         max_retries = 3
1580
1581         while retry < max_retries:
1582             retry += 1
1583             try:
1584                 self._reload_connection()
1585
1586                 # determine format  http://docs.openstack.org/developer/glance/formats.html
1587                 if "disk_format" in image_dict:
1588                     disk_format = image_dict["disk_format"]
1589                 else:  # autodiscover based on extension
1590                     if image_dict["location"].endswith(".qcow2"):
1591                         disk_format = "qcow2"
1592                     elif image_dict["location"].endswith(".vhd"):
1593                         disk_format = "vhd"
1594                     elif image_dict["location"].endswith(".vmdk"):
1595                         disk_format = "vmdk"
1596                     elif image_dict["location"].endswith(".vdi"):
1597                         disk_format = "vdi"
1598                     elif image_dict["location"].endswith(".iso"):
1599                         disk_format = "iso"
1600                     elif image_dict["location"].endswith(".aki"):
1601                         disk_format = "aki"
1602                     elif image_dict["location"].endswith(".ari"):
1603                         disk_format = "ari"
1604                     elif image_dict["location"].endswith(".ami"):
1605                         disk_format = "ami"
1606                     else:
1607                         disk_format = "raw"
1608
1609                 self.logger.debug(
1610                     "new_image: '%s' loading from '%s'",
1611                     image_dict["name"],
1612                     image_dict["location"],
1613                 )
1614                 if self.vim_type == "VIO":
1615                     container_format = "bare"
1616                     if "container_format" in image_dict:
1617                         container_format = image_dict["container_format"]
1618
1619                     new_image = self.glance.images.create(
1620                         name=image_dict["name"],
1621                         container_format=container_format,
1622                         disk_format=disk_format,
1623                     )
1624                 else:
1625                     new_image = self.glance.images.create(name=image_dict["name"])
1626
1627                 if image_dict["location"].startswith("http"):
1628                     # TODO there is not a method to direct download. It must be downloaded locally with requests
1629                     raise vimconn.VimConnNotImplemented("Cannot create image from URL")
1630                 else:  # local path
1631                     with open(image_dict["location"]) as fimage:
1632                         self.glance.images.upload(new_image.id, fimage)
1633                         # new_image = self.glancev1.images.create(name=image_dict["name"], is_public=
1634                         #  image_dict.get("public","yes")=="yes",
1635                         #    container_format="bare", data=fimage, disk_format=disk_format)
1636
1637                 metadata_to_load = image_dict.get("metadata")
1638
1639                 # TODO location is a reserved word for current openstack versions. fixed for VIO please check
1640                 #  for openstack
1641                 if self.vim_type == "VIO":
1642                     metadata_to_load["upload_location"] = image_dict["location"]
1643                 else:
1644                     metadata_to_load["location"] = image_dict["location"]
1645
1646                 self.glance.images.update(new_image.id, **metadata_to_load)
1647
1648                 return new_image.id
1649             except (
1650                 nvExceptions.Conflict,
1651                 ksExceptions.ClientException,
1652                 nvExceptions.ClientException,
1653             ) as e:
1654                 self._format_exception(e)
1655             except (
1656                 HTTPException,
1657                 gl1Exceptions.HTTPException,
1658                 gl1Exceptions.CommunicationError,
1659                 ConnectionError,
1660             ) as e:
1661                 if retry == max_retries:
1662                     continue
1663
1664                 self._format_exception(e)
1665             except IOError as e:  # can not open the file
1666                 raise vimconn.VimConnConnectionException(
1667                     "{}: {} for {}".format(type(e).__name__, e, image_dict["location"]),
1668                     http_code=vimconn.HTTP_Bad_Request,
1669                 )
1670
1671     def delete_image(self, image_id):
1672         """Deletes a tenant image from openstack VIM. Returns the old id"""
1673         try:
1674             self._reload_connection()
1675             self.glance.images.delete(image_id)
1676
1677             return image_id
1678         except (
1679             nvExceptions.NotFound,
1680             ksExceptions.ClientException,
1681             nvExceptions.ClientException,
1682             gl1Exceptions.CommunicationError,
1683             gl1Exceptions.HTTPNotFound,
1684             ConnectionError,
1685         ) as e:  # TODO remove
1686             self._format_exception(e)
1687
1688     def get_image_id_from_path(self, path):
1689         """Get the image id from image path in the VIM database. Returns the image_id"""
1690         try:
1691             self._reload_connection()
1692             images = self.glance.images.list()
1693
1694             for image in images:
1695                 if image.metadata.get("location") == path:
1696                     return image.id
1697
1698             raise vimconn.VimConnNotFoundException(
1699                 "image with location '{}' not found".format(path)
1700             )
1701         except (
1702             ksExceptions.ClientException,
1703             nvExceptions.ClientException,
1704             gl1Exceptions.CommunicationError,
1705             ConnectionError,
1706         ) as e:
1707             self._format_exception(e)
1708
1709     def get_image_list(self, filter_dict={}):
1710         """Obtain tenant images from VIM
1711         Filter_dict can be:
1712             id: image id
1713             name: image name
1714             checksum: image checksum
1715         Returns the image list of dictionaries:
1716             [{<the fields at Filter_dict plus some VIM specific>}, ...]
1717             List can be empty
1718         """
1719         self.logger.debug("Getting image list from VIM filter: '%s'", str(filter_dict))
1720
1721         try:
1722             self._reload_connection()
1723             # filter_dict_os = filter_dict.copy()
1724             # First we filter by the available filter fields: name, id. The others are removed.
1725             image_list = self.glance.images.list()
1726             filtered_list = []
1727
1728             for image in image_list:
1729                 try:
1730                     if filter_dict.get("name") and image["name"] != filter_dict["name"]:
1731                         continue
1732
1733                     if filter_dict.get("id") and image["id"] != filter_dict["id"]:
1734                         continue
1735
1736                     if (
1737                         filter_dict.get("checksum")
1738                         and image["checksum"] != filter_dict["checksum"]
1739                     ):
1740                         continue
1741
1742                     filtered_list.append(image.copy())
1743                 except gl1Exceptions.HTTPNotFound:
1744                     pass
1745
1746             return filtered_list
1747         except (
1748             ksExceptions.ClientException,
1749             nvExceptions.ClientException,
1750             gl1Exceptions.CommunicationError,
1751             ConnectionError,
1752         ) as e:
1753             self._format_exception(e)
1754
1755     def __wait_for_vm(self, vm_id, status):
1756         """wait until vm is in the desired status and return True.
1757         If the VM gets in ERROR status, return false.
1758         If the timeout is reached generate an exception"""
1759         elapsed_time = 0
1760         while elapsed_time < server_timeout:
1761             vm_status = self.nova.servers.get(vm_id).status
1762
1763             if vm_status == status:
1764                 return True
1765
1766             if vm_status == "ERROR":
1767                 return False
1768
1769             time.sleep(5)
1770             elapsed_time += 5
1771
1772         # if we exceeded the timeout rollback
1773         if elapsed_time >= server_timeout:
1774             raise vimconn.VimConnException(
1775                 "Timeout waiting for instance " + vm_id + " to get " + status,
1776                 http_code=vimconn.HTTP_Request_Timeout,
1777             )
1778
1779     def _get_openstack_availablity_zones(self):
1780         """
1781         Get from openstack availability zones available
1782         :return:
1783         """
1784         try:
1785             openstack_availability_zone = self.nova.availability_zones.list()
1786             openstack_availability_zone = [
1787                 str(zone.zoneName)
1788                 for zone in openstack_availability_zone
1789                 if zone.zoneName != "internal"
1790             ]
1791
1792             return openstack_availability_zone
1793         except Exception:
1794             return None
1795
1796     def _set_availablity_zones(self):
1797         """
1798         Set vim availablity zone
1799         :return:
1800         """
1801         if "availability_zone" in self.config:
1802             vim_availability_zones = self.config.get("availability_zone")
1803
1804             if isinstance(vim_availability_zones, str):
1805                 self.availability_zone = [vim_availability_zones]
1806             elif isinstance(vim_availability_zones, list):
1807                 self.availability_zone = vim_availability_zones
1808         else:
1809             self.availability_zone = self._get_openstack_availablity_zones()
1810
1811     def _get_vm_availability_zone(
1812         self, availability_zone_index, availability_zone_list
1813     ):
1814         """
1815         Return thge availability zone to be used by the created VM.
1816         :return: The VIM availability zone to be used or None
1817         """
1818         if availability_zone_index is None:
1819             if not self.config.get("availability_zone"):
1820                 return None
1821             elif isinstance(self.config.get("availability_zone"), str):
1822                 return self.config["availability_zone"]
1823             else:
1824                 # TODO consider using a different parameter at config for default AV and AV list match
1825                 return self.config["availability_zone"][0]
1826
1827         vim_availability_zones = self.availability_zone
1828         # check if VIM offer enough availability zones describe in the VNFD
1829         if vim_availability_zones and len(availability_zone_list) <= len(
1830             vim_availability_zones
1831         ):
1832             # check if all the names of NFV AV match VIM AV names
1833             match_by_index = False
1834             for av in availability_zone_list:
1835                 if av not in vim_availability_zones:
1836                     match_by_index = True
1837                     break
1838
1839             if match_by_index:
1840                 return vim_availability_zones[availability_zone_index]
1841             else:
1842                 return availability_zone_list[availability_zone_index]
1843         else:
1844             raise vimconn.VimConnConflictException(
1845                 "No enough availability zones at VIM for this deployment"
1846             )
1847
1848     def _prepare_port_dict_security_groups(self, net: dict, port_dict: dict) -> None:
1849         """Fill up the security_groups in the port_dict.
1850
1851         Args:
1852             net (dict):             Network details
1853             port_dict   (dict):     Port details
1854
1855         """
1856         if (
1857             self.config.get("security_groups")
1858             and net.get("port_security") is not False
1859             and not self.config.get("no_port_security_extension")
1860         ):
1861             if not self.security_groups_id:
1862                 self._get_ids_from_name()
1863
1864             port_dict["security_groups"] = self.security_groups_id
1865
1866     def _prepare_port_dict_binding(self, net: dict, port_dict: dict) -> None:
1867         """Fill up the network binding depending on network type in the port_dict.
1868
1869         Args:
1870             net (dict):             Network details
1871             port_dict   (dict):     Port details
1872
1873         """
1874         if not net.get("type"):
1875             raise vimconn.VimConnException("Type is missing in the network details.")
1876
1877         if net["type"] == "virtual":
1878             pass
1879
1880         # For VF
1881         elif net["type"] == "VF" or net["type"] == "SR-IOV":
1882             port_dict["binding:vnic_type"] = "direct"
1883
1884             # VIO specific Changes
1885             if self.vim_type == "VIO":
1886                 # Need to create port with port_security_enabled = False and no-security-groups
1887                 port_dict["port_security_enabled"] = False
1888                 port_dict["provider_security_groups"] = []
1889                 port_dict["security_groups"] = []
1890
1891         else:
1892             # For PT PCI-PASSTHROUGH
1893             port_dict["binding:vnic_type"] = "direct-physical"
1894
1895     @staticmethod
1896     def _set_fixed_ip(new_port: dict, net: dict) -> None:
1897         """Set the "ip" parameter in net dictionary.
1898
1899         Args:
1900             new_port    (dict):     New created port
1901             net         (dict):     Network details
1902
1903         """
1904         fixed_ips = new_port["port"].get("fixed_ips")
1905
1906         if fixed_ips:
1907             net["ip"] = fixed_ips[0].get("ip_address")
1908         else:
1909             net["ip"] = None
1910
1911     @staticmethod
1912     def _prepare_port_dict_mac_ip_addr(net: dict, port_dict: dict) -> None:
1913         """Fill up the mac_address and fixed_ips in port_dict.
1914
1915         Args:
1916             net (dict):             Network details
1917             port_dict   (dict):     Port details
1918
1919         """
1920         if net.get("mac_address"):
1921             port_dict["mac_address"] = net["mac_address"]
1922
1923         if net.get("ip_address"):
1924             port_dict["fixed_ips"] = [{"ip_address": net["ip_address"]}]
1925             # TODO add "subnet_id": <subnet_id>
1926
1927     def _create_new_port(self, port_dict: dict, created_items: dict, net: dict) -> Dict:
1928         """Create new port using neutron.
1929
1930         Args:
1931             port_dict   (dict):         Port details
1932             created_items   (dict):     All created items
1933             net (dict):                 Network details
1934
1935         Returns:
1936             new_port    (dict):         New created port
1937
1938         """
1939         new_port = self.neutron.create_port({"port": port_dict})
1940         created_items["port:" + str(new_port["port"]["id"])] = True
1941         net["mac_adress"] = new_port["port"]["mac_address"]
1942         net["vim_id"] = new_port["port"]["id"]
1943
1944         return new_port
1945
1946     def _create_port(
1947         self, net: dict, name: str, created_items: dict
1948     ) -> Tuple[dict, dict]:
1949         """Create port using net details.
1950
1951         Args:
1952             net (dict):                 Network details
1953             name    (str):              Name to be used as network name if net dict does not include name
1954             created_items   (dict):     All created items
1955
1956         Returns:
1957             new_port, port              New created port, port dictionary
1958
1959         """
1960
1961         port_dict = {
1962             "network_id": net["net_id"],
1963             "name": net.get("name"),
1964             "admin_state_up": True,
1965         }
1966
1967         if not port_dict["name"]:
1968             port_dict["name"] = name
1969
1970         self._prepare_port_dict_security_groups(net, port_dict)
1971
1972         self._prepare_port_dict_binding(net, port_dict)
1973
1974         vimconnector._prepare_port_dict_mac_ip_addr(net, port_dict)
1975
1976         new_port = self._create_new_port(port_dict, created_items, net)
1977
1978         vimconnector._set_fixed_ip(new_port, net)
1979
1980         port = {"port-id": new_port["port"]["id"]}
1981
1982         if float(self.nova.api_version.get_string()) >= 2.32:
1983             port["tag"] = new_port["port"]["name"]
1984
1985         return new_port, port
1986
1987     def _prepare_network_for_vminstance(
1988         self,
1989         name: str,
1990         net_list: list,
1991         created_items: dict,
1992         net_list_vim: list,
1993         external_network: list,
1994         no_secured_ports: list,
1995     ) -> None:
1996         """Create port and fill up net dictionary for new VM instance creation.
1997
1998         Args:
1999             name    (str):                  Name of network
2000             net_list    (list):             List of networks
2001             created_items   (dict):         All created items belongs to a VM
2002             net_list_vim    (list):         List of ports
2003             external_network    (list):     List of external-networks
2004             no_secured_ports    (list):     Port security disabled ports
2005         """
2006
2007         self._reload_connection()
2008
2009         for net in net_list:
2010             # Skip non-connected iface
2011             if not net.get("net_id"):
2012                 continue
2013
2014             new_port, port = self._create_port(net, name, created_items)
2015
2016             net_list_vim.append(port)
2017
2018             if net.get("floating_ip", False):
2019                 net["exit_on_floating_ip_error"] = True
2020                 external_network.append(net)
2021
2022             elif net["use"] == "mgmt" and self.config.get("use_floating_ip"):
2023                 net["exit_on_floating_ip_error"] = False
2024                 external_network.append(net)
2025                 net["floating_ip"] = self.config.get("use_floating_ip")
2026
2027             # If port security is disabled when the port has not yet been attached to the VM, then all vm traffic
2028             # is dropped. As a workaround we wait until the VM is active and then disable the port-security
2029             if net.get("port_security") is False and not self.config.get(
2030                 "no_port_security_extension"
2031             ):
2032                 no_secured_ports.append(
2033                     (
2034                         new_port["port"]["id"],
2035                         net.get("port_security_disable_strategy"),
2036                     )
2037                 )
2038
2039     def _prepare_persistent_root_volumes(
2040         self,
2041         name: str,
2042         vm_av_zone: list,
2043         disk: dict,
2044         base_disk_index: int,
2045         block_device_mapping: dict,
2046         existing_vim_volumes: list,
2047         created_items: dict,
2048     ) -> Optional[str]:
2049         """Prepare persistent root volumes for new VM instance.
2050
2051         Args:
2052             name    (str):                      Name of VM instance
2053             vm_av_zone  (list):                 List of availability zones
2054             disk    (dict):                     Disk details
2055             base_disk_index (int):              Disk index
2056             block_device_mapping    (dict):     Block device details
2057             existing_vim_volumes    (list):     Existing disk details
2058             created_items   (dict):             All created items belongs to VM
2059
2060         Returns:
2061             boot_volume_id  (str):              ID of boot volume
2062
2063         """
2064         # Disk may include only vim_volume_id or only vim_id."
2065         # Use existing persistent root volume finding with volume_id or vim_id
2066         key_id = "vim_volume_id" if "vim_volume_id" in disk.keys() else "vim_id"
2067
2068         if disk.get(key_id):
2069             block_device_mapping["vd" + chr(base_disk_index)] = disk[key_id]
2070             existing_vim_volumes.append({"id": disk[key_id]})
2071
2072         else:
2073             # Create persistent root volume
2074             volume = self.cinder.volumes.create(
2075                 size=disk["size"],
2076                 name=name + "vd" + chr(base_disk_index),
2077                 imageRef=disk["image_id"],
2078                 # Make sure volume is in the same AZ as the VM to be attached to
2079                 availability_zone=vm_av_zone,
2080             )
2081             boot_volume_id = volume.id
2082             created_items["volume:" + str(volume.id)] = True
2083             block_device_mapping["vd" + chr(base_disk_index)] = volume.id
2084
2085             return boot_volume_id
2086
2087     def _prepare_non_root_persistent_volumes(
2088         self,
2089         name: str,
2090         disk: dict,
2091         vm_av_zone: list,
2092         block_device_mapping: dict,
2093         base_disk_index: int,
2094         existing_vim_volumes: list,
2095         created_items: dict,
2096     ) -> None:
2097         """Prepare persistent volumes for new VM instance.
2098
2099         Args:
2100             name    (str):                      Name of VM instance
2101             disk    (dict):                     Disk details
2102             vm_av_zone  (list):                 List of availability zones
2103             block_device_mapping    (dict):     Block device details
2104             base_disk_index (int):              Disk index
2105             existing_vim_volumes    (list):     Existing disk details
2106             created_items   (dict):             All created items belongs to VM
2107         """
2108         # Non-root persistent volumes
2109         # Disk may include only vim_volume_id or only vim_id."
2110         key_id = "vim_volume_id" if "vim_volume_id" in disk.keys() else "vim_id"
2111
2112         if disk.get(key_id):
2113             # Use existing persistent volume
2114             block_device_mapping["vd" + chr(base_disk_index)] = disk[key_id]
2115             existing_vim_volumes.append({"id": disk[key_id]})
2116
2117         else:
2118             # Create persistent volume
2119             volume = self.cinder.volumes.create(
2120                 size=disk["size"],
2121                 name=name + "vd" + chr(base_disk_index),
2122                 # Make sure volume is in the same AZ as the VM to be attached to
2123                 availability_zone=vm_av_zone,
2124             )
2125             created_items["volume:" + str(volume.id)] = True
2126             block_device_mapping["vd" + chr(base_disk_index)] = volume.id
2127
2128     def _wait_for_created_volumes_availability(
2129         self, elapsed_time: int, created_items: dict
2130     ) -> Optional[int]:
2131         """Wait till created volumes become available.
2132
2133         Args:
2134             elapsed_time    (int):          Passed time while waiting
2135             created_items   (dict):         All created items belongs to VM
2136
2137         Returns:
2138             elapsed_time    (int):          Time spent while waiting
2139
2140         """
2141
2142         while elapsed_time < volume_timeout:
2143             for created_item in created_items:
2144                 v, _, volume_id = created_item.partition(":")
2145                 if v == "volume":
2146                     if self.cinder.volumes.get(volume_id).status != "available":
2147                         break
2148             else:
2149                 # All ready: break from while
2150                 break
2151
2152             time.sleep(5)
2153             elapsed_time += 5
2154
2155         return elapsed_time
2156
2157     def _wait_for_existing_volumes_availability(
2158         self, elapsed_time: int, existing_vim_volumes: list
2159     ) -> Optional[int]:
2160         """Wait till existing volumes become available.
2161
2162         Args:
2163             elapsed_time    (int):          Passed time while waiting
2164             existing_vim_volumes   (list):  Existing volume details
2165
2166         Returns:
2167             elapsed_time    (int):          Time spent while waiting
2168
2169         """
2170
2171         while elapsed_time < volume_timeout:
2172             for volume in existing_vim_volumes:
2173                 if self.cinder.volumes.get(volume["id"]).status != "available":
2174                     break
2175             else:  # all ready: break from while
2176                 break
2177
2178             time.sleep(5)
2179             elapsed_time += 5
2180
2181         return elapsed_time
2182
2183     def _prepare_disk_for_vminstance(
2184         self,
2185         name: str,
2186         existing_vim_volumes: list,
2187         created_items: dict,
2188         vm_av_zone: list,
2189         disk_list: list = None,
2190     ) -> None:
2191         """Prepare all volumes for new VM instance.
2192
2193         Args:
2194             name    (str):                      Name of Instance
2195             existing_vim_volumes    (list):     List of existing volumes
2196             created_items   (dict):             All created items belongs to VM
2197             vm_av_zone  (list):                 VM availability zone
2198             disk_list   (list):                 List of disks
2199
2200         """
2201         # Create additional volumes in case these are present in disk_list
2202         base_disk_index = ord("b")
2203         boot_volume_id = None
2204         elapsed_time = 0
2205
2206         block_device_mapping = {}
2207         for disk in disk_list:
2208             if "image_id" in disk:
2209                 # Root persistent volume
2210                 base_disk_index = ord("a")
2211                 boot_volume_id = self._prepare_persistent_root_volumes(
2212                     name=name,
2213                     vm_av_zone=vm_av_zone,
2214                     disk=disk,
2215                     base_disk_index=base_disk_index,
2216                     block_device_mapping=block_device_mapping,
2217                     existing_vim_volumes=existing_vim_volumes,
2218                     created_items=created_items,
2219                 )
2220             else:
2221                 # Non-root persistent volume
2222                 self._prepare_non_root_persistent_volumes(
2223                     name=name,
2224                     disk=disk,
2225                     vm_av_zone=vm_av_zone,
2226                     block_device_mapping=block_device_mapping,
2227                     base_disk_index=base_disk_index,
2228                     existing_vim_volumes=existing_vim_volumes,
2229                     created_items=created_items,
2230                 )
2231             base_disk_index += 1
2232
2233         # Wait until created volumes are with status available
2234         elapsed_time = self._wait_for_created_volumes_availability(
2235             elapsed_time, created_items
2236         )
2237         # Wait until existing volumes in vim are with status available
2238         elapsed_time = self._wait_for_existing_volumes_availability(
2239             elapsed_time, existing_vim_volumes
2240         )
2241         # If we exceeded the timeout rollback
2242         if elapsed_time >= volume_timeout:
2243             raise vimconn.VimConnException(
2244                 "Timeout creating volumes for instance " + name,
2245                 http_code=vimconn.HTTP_Request_Timeout,
2246             )
2247         if boot_volume_id:
2248             self.cinder.volumes.set_bootable(boot_volume_id, True)
2249
2250     def _find_the_external_network_for_floating_ip(self):
2251         """Get the external network ip in order to create floating IP.
2252
2253         Returns:
2254             pool_id (str):      External network pool ID
2255
2256         """
2257
2258         # Find the external network
2259         external_nets = list()
2260
2261         for net in self.neutron.list_networks()["networks"]:
2262             if net["router:external"]:
2263                 external_nets.append(net)
2264
2265         if len(external_nets) == 0:
2266             raise vimconn.VimConnException(
2267                 "Cannot create floating_ip automatically since "
2268                 "no external network is present",
2269                 http_code=vimconn.HTTP_Conflict,
2270             )
2271
2272         if len(external_nets) > 1:
2273             raise vimconn.VimConnException(
2274                 "Cannot create floating_ip automatically since "
2275                 "multiple external networks are present",
2276                 http_code=vimconn.HTTP_Conflict,
2277             )
2278
2279         # Pool ID
2280         return external_nets[0].get("id")
2281
2282     def _neutron_create_float_ip(self, param: dict, created_items: dict) -> None:
2283         """Trigger neutron to create a new floating IP using external network ID.
2284
2285         Args:
2286             param   (dict):             Input parameters to create a floating IP
2287             created_items   (dict):     All created items belongs to new VM instance
2288
2289         Raises:
2290
2291             VimConnException
2292         """
2293         try:
2294             self.logger.debug("Creating floating IP")
2295             new_floating_ip = self.neutron.create_floatingip(param)
2296             free_floating_ip = new_floating_ip["floatingip"]["id"]
2297             created_items["floating_ip:" + str(free_floating_ip)] = True
2298
2299         except Exception as e:
2300             raise vimconn.VimConnException(
2301                 type(e).__name__ + ": Cannot create new floating_ip " + str(e),
2302                 http_code=vimconn.HTTP_Conflict,
2303             )
2304
2305     def _create_floating_ip(
2306         self, floating_network: dict, server: object, created_items: dict
2307     ) -> None:
2308         """Get the available Pool ID and create a new floating IP.
2309
2310         Args:
2311             floating_network    (dict):         Dict including external network ID
2312             server   (object):                  Server object
2313             created_items   (dict):             All created items belongs to new VM instance
2314
2315         """
2316
2317         # Pool_id is available
2318         if (
2319             isinstance(floating_network["floating_ip"], str)
2320             and floating_network["floating_ip"].lower() != "true"
2321         ):
2322             pool_id = floating_network["floating_ip"]
2323
2324         # Find the Pool_id
2325         else:
2326             pool_id = self._find_the_external_network_for_floating_ip()
2327
2328         param = {
2329             "floatingip": {
2330                 "floating_network_id": pool_id,
2331                 "tenant_id": server.tenant_id,
2332             }
2333         }
2334
2335         self._neutron_create_float_ip(param, created_items)
2336
2337     def _find_floating_ip(
2338         self,
2339         server: object,
2340         floating_ips: list,
2341         floating_network: dict,
2342     ) -> Optional[str]:
2343         """Find the available free floating IPs if there are.
2344
2345         Args:
2346             server  (object):                   Server object
2347             floating_ips    (list):             List of floating IPs
2348             floating_network    (dict):         Details of floating network such as ID
2349
2350         Returns:
2351             free_floating_ip    (str):          Free floating ip address
2352
2353         """
2354         for fip in floating_ips:
2355             if fip.get("port_id") or fip.get("tenant_id") != server.tenant_id:
2356                 continue
2357
2358             if isinstance(floating_network["floating_ip"], str):
2359                 if fip.get("floating_network_id") != floating_network["floating_ip"]:
2360                     continue
2361
2362             return fip["id"]
2363
2364     def _assign_floating_ip(
2365         self, free_floating_ip: str, floating_network: dict
2366     ) -> Dict:
2367         """Assign the free floating ip address to port.
2368
2369         Args:
2370             free_floating_ip    (str):          Floating IP to be assigned
2371             floating_network    (dict):         ID of floating network
2372
2373         Returns:
2374             fip (dict)          (dict):         Floating ip details
2375
2376         """
2377         # The vim_id key contains the neutron.port_id
2378         self.neutron.update_floatingip(
2379             free_floating_ip,
2380             {"floatingip": {"port_id": floating_network["vim_id"]}},
2381         )
2382         # For race condition ensure not re-assigned to other VM after 5 seconds
2383         time.sleep(5)
2384
2385         return self.neutron.show_floatingip(free_floating_ip)
2386
2387     def _get_free_floating_ip(
2388         self, server: object, floating_network: dict
2389     ) -> Optional[str]:
2390         """Get the free floating IP address.
2391
2392         Args:
2393             server  (object):               Server Object
2394             floating_network    (dict):     Floating network details
2395
2396         Returns:
2397             free_floating_ip    (str):      Free floating ip addr
2398
2399         """
2400
2401         floating_ips = self.neutron.list_floatingips().get("floatingips", ())
2402
2403         # Randomize
2404         random.shuffle(floating_ips)
2405
2406         return self._find_floating_ip(server, floating_ips, floating_network)
2407
2408     def _prepare_external_network_for_vminstance(
2409         self,
2410         external_network: list,
2411         server: object,
2412         created_items: dict,
2413         vm_start_time: float,
2414     ) -> None:
2415         """Assign floating IP address for VM instance.
2416
2417         Args:
2418             external_network    (list):         ID of External network
2419             server  (object):                   Server Object
2420             created_items   (dict):             All created items belongs to new VM instance
2421             vm_start_time   (float):            Time as a floating point number expressed in seconds since the epoch, in UTC
2422
2423         Raises:
2424             VimConnException
2425
2426         """
2427         for floating_network in external_network:
2428             try:
2429                 assigned = False
2430                 floating_ip_retries = 3
2431                 # In case of RO in HA there can be conflicts, two RO trying to assign same floating IP, so retry
2432                 # several times
2433                 while not assigned:
2434                     free_floating_ip = self._get_free_floating_ip(
2435                         server, floating_network
2436                     )
2437
2438                     if not free_floating_ip:
2439                         self._create_floating_ip(
2440                             floating_network, server, created_items
2441                         )
2442
2443                     try:
2444                         # For race condition ensure not already assigned
2445                         fip = self.neutron.show_floatingip(free_floating_ip)
2446
2447                         if fip["floatingip"].get("port_id"):
2448                             continue
2449
2450                         # Assign floating ip
2451                         fip = self._assign_floating_ip(
2452                             free_floating_ip, floating_network
2453                         )
2454
2455                         if fip["floatingip"]["port_id"] != floating_network["vim_id"]:
2456                             self.logger.warning(
2457                                 "floating_ip {} re-assigned to other port".format(
2458                                     free_floating_ip
2459                                 )
2460                             )
2461                             continue
2462
2463                         self.logger.debug(
2464                             "Assigned floating_ip {} to VM {}".format(
2465                                 free_floating_ip, server.id
2466                             )
2467                         )
2468
2469                         assigned = True
2470
2471                     except Exception as e:
2472                         # Openstack need some time after VM creation to assign an IP. So retry if fails
2473                         vm_status = self.nova.servers.get(server.id).status
2474
2475                         if vm_status not in ("ACTIVE", "ERROR"):
2476                             if time.time() - vm_start_time < server_timeout:
2477                                 time.sleep(5)
2478                                 continue
2479                         elif floating_ip_retries > 0:
2480                             floating_ip_retries -= 1
2481                             continue
2482
2483                         raise vimconn.VimConnException(
2484                             "Cannot create floating_ip: {} {}".format(
2485                                 type(e).__name__, e
2486                             ),
2487                             http_code=vimconn.HTTP_Conflict,
2488                         )
2489
2490             except Exception as e:
2491                 if not floating_network["exit_on_floating_ip_error"]:
2492                     self.logger.error("Cannot create floating_ip. %s", str(e))
2493                     continue
2494
2495                 raise
2496
2497     def _update_port_security_for_vminstance(
2498         self,
2499         no_secured_ports: list,
2500         server: object,
2501     ) -> None:
2502         """Updates the port security according to no_secured_ports list.
2503
2504         Args:
2505             no_secured_ports    (list):     List of ports that security will be disabled
2506             server  (object):               Server Object
2507
2508         Raises:
2509             VimConnException
2510
2511         """
2512         # Wait until the VM is active and then disable the port-security
2513         if no_secured_ports:
2514             self.__wait_for_vm(server.id, "ACTIVE")
2515
2516         for port in no_secured_ports:
2517             port_update = {
2518                 "port": {"port_security_enabled": False, "security_groups": None}
2519             }
2520
2521             if port[1] == "allow-address-pairs":
2522                 port_update = {
2523                     "port": {"allowed_address_pairs": [{"ip_address": "0.0.0.0/0"}]}
2524                 }
2525
2526             try:
2527                 self.neutron.update_port(port[0], port_update)
2528
2529             except Exception:
2530                 raise vimconn.VimConnException(
2531                     "It was not possible to disable port security for port {}".format(
2532                         port[0]
2533                     )
2534                 )
2535
2536     def new_vminstance(
2537         self,
2538         name: str,
2539         description: str,
2540         start: bool,
2541         image_id: str,
2542         flavor_id: str,
2543         affinity_group_list: list,
2544         net_list: list,
2545         cloud_config=None,
2546         disk_list=None,
2547         availability_zone_index=None,
2548         availability_zone_list=None,
2549     ) -> tuple:
2550         """Adds a VM instance to VIM.
2551
2552         Args:
2553             name    (str):          name of VM
2554             description (str):      description
2555             start   (bool):         indicates if VM must start or boot in pause mode. Ignored
2556             image_id    (str)       image uuid
2557             flavor_id   (str)       flavor uuid
2558             affinity_group_list (list):     list of affinity groups, each one is a dictionary.Ignore if empty.
2559             net_list    (list):         list of interfaces, each one is a dictionary with:
2560                 name:   name of network
2561                 net_id:     network uuid to connect
2562                 vpci:   virtual vcpi to assign, ignored because openstack lack #TODO
2563                 model:  interface model, ignored #TODO
2564                 mac_address:    used for  SR-IOV ifaces #TODO for other types
2565                 use:    'data', 'bridge',  'mgmt'
2566                 type:   'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
2567                 vim_id:     filled/added by this function
2568                 floating_ip:    True/False (or it can be None)
2569                 port_security:  True/False
2570             cloud_config    (dict): (optional) dictionary with:
2571                 key-pairs:      (optional) list of strings with the public key to be inserted to the default user
2572                 users:      (optional) list of users to be inserted, each item is a dict with:
2573                     name:   (mandatory) user name,
2574                     key-pairs: (optional) list of strings with the public key to be inserted to the user
2575                 user-data:  (optional) string is a text script to be passed directly to cloud-init
2576                 config-files:   (optional). List of files to be transferred. Each item is a dict with:
2577                     dest:   (mandatory) string with the destination absolute path
2578                     encoding:   (optional, by default text). Can be one of:
2579                         'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
2580                     content :    (mandatory) string with the content of the file
2581                     permissions:    (optional) string with file permissions, typically octal notation '0644'
2582                     owner:  (optional) file owner, string with the format 'owner:group'
2583                 boot-data-drive:    boolean to indicate if user-data must be passed using a boot drive (hard disk)
2584             disk_list:  (optional) list with additional disks to the VM. Each item is a dict with:
2585                 image_id:   (optional). VIM id of an existing image. If not provided an empty disk must be mounted
2586                 size:   (mandatory) string with the size of the disk in GB
2587                 vim_id:  (optional) should use this existing volume id
2588             availability_zone_index:    Index of availability_zone_list to use for this this VM. None if not AV required
2589             availability_zone_list:     list of availability zones given by user in the VNFD descriptor.  Ignore if
2590                 availability_zone_index is None
2591                 #TODO ip, security groups
2592
2593         Returns:
2594             A tuple with the instance identifier and created_items or raises an exception on error
2595             created_items can be None or a dictionary where this method can include key-values that will be passed to
2596             the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
2597             Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
2598             as not present.
2599         """
2600         self.logger.debug(
2601             "new_vminstance input: image='%s' flavor='%s' nics='%s'",
2602             image_id,
2603             flavor_id,
2604             str(net_list),
2605         )
2606
2607         try:
2608             server = None
2609             created_items = {}
2610             net_list_vim = []
2611             # list of external networks to be connected to instance, later on used to create floating_ip
2612             external_network = []
2613             # List of ports with port-security disabled
2614             no_secured_ports = []
2615             block_device_mapping = None
2616             existing_vim_volumes = []
2617             server_group_id = None
2618             scheduller_hints = {}
2619
2620             # Check the Openstack Connection
2621             self._reload_connection()
2622
2623             # Prepare network list
2624             self._prepare_network_for_vminstance(
2625                 name=name,
2626                 net_list=net_list,
2627                 created_items=created_items,
2628                 net_list_vim=net_list_vim,
2629                 external_network=external_network,
2630                 no_secured_ports=no_secured_ports,
2631             )
2632
2633             # Cloud config
2634             config_drive, userdata = self._create_user_data(cloud_config)
2635
2636             # Get availability Zone
2637             vm_av_zone = self._get_vm_availability_zone(
2638                 availability_zone_index, availability_zone_list
2639             )
2640
2641             if disk_list:
2642                 # Prepare disks
2643                 self._prepare_disk_for_vminstance(
2644                     name=name,
2645                     existing_vim_volumes=existing_vim_volumes,
2646                     created_items=created_items,
2647                     vm_av_zone=vm_av_zone,
2648                     disk_list=disk_list,
2649                 )
2650
2651             if affinity_group_list:
2652                 # Only first id on the list will be used. Openstack restriction
2653                 server_group_id = affinity_group_list[0]["affinity_group_id"]
2654                 scheduller_hints["group"] = server_group_id
2655
2656             self.logger.debug(
2657                 "nova.servers.create({}, {}, {}, nics={}, security_groups={}, "
2658                 "availability_zone={}, key_name={}, userdata={}, config_drive={}, "
2659                 "block_device_mapping={}, server_group={})".format(
2660                     name,
2661                     image_id,
2662                     flavor_id,
2663                     net_list_vim,
2664                     self.config.get("security_groups"),
2665                     vm_av_zone,
2666                     self.config.get("keypair"),
2667                     userdata,
2668                     config_drive,
2669                     block_device_mapping,
2670                     server_group_id,
2671                 )
2672             )
2673
2674             # Create VM
2675             server = self.nova.servers.create(
2676                 name=name,
2677                 image=image_id,
2678                 flavor=flavor_id,
2679                 nics=net_list_vim,
2680                 security_groups=self.config.get("security_groups"),
2681                 # TODO remove security_groups in future versions. Already at neutron port
2682                 availability_zone=vm_av_zone,
2683                 key_name=self.config.get("keypair"),
2684                 userdata=userdata,
2685                 config_drive=config_drive,
2686                 block_device_mapping=block_device_mapping,
2687                 scheduler_hints=scheduller_hints,
2688             )
2689
2690             vm_start_time = time.time()
2691
2692             self._update_port_security_for_vminstance(no_secured_ports, server)
2693
2694             self._prepare_external_network_for_vminstance(
2695                 external_network=external_network,
2696                 server=server,
2697                 created_items=created_items,
2698                 vm_start_time=vm_start_time,
2699             )
2700
2701             return server.id, created_items
2702
2703         except Exception as e:
2704             server_id = None
2705             if server:
2706                 server_id = server.id
2707
2708             try:
2709                 self.delete_vminstance(server_id, created_items)
2710
2711             except Exception as e2:
2712                 self.logger.error("new_vminstance rollback fail {}".format(e2))
2713
2714             self._format_exception(e)
2715
2716     def get_vminstance(self, vm_id):
2717         """Returns the VM instance information from VIM"""
2718         # self.logger.debug("Getting VM from VIM")
2719         try:
2720             self._reload_connection()
2721             server = self.nova.servers.find(id=vm_id)
2722             # TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
2723
2724             return server.to_dict()
2725         except (
2726             ksExceptions.ClientException,
2727             nvExceptions.ClientException,
2728             nvExceptions.NotFound,
2729             ConnectionError,
2730         ) as e:
2731             self._format_exception(e)
2732
2733     def get_vminstance_console(self, vm_id, console_type="vnc"):
2734         """
2735         Get a console for the virtual machine
2736         Params:
2737             vm_id: uuid of the VM
2738             console_type, can be:
2739                 "novnc" (by default), "xvpvnc" for VNC types,
2740                 "rdp-html5" for RDP types, "spice-html5" for SPICE types
2741         Returns dict with the console parameters:
2742                 protocol: ssh, ftp, http, https, ...
2743                 server:   usually ip address
2744                 port:     the http, ssh, ... port
2745                 suffix:   extra text, e.g. the http path and query string
2746         """
2747         self.logger.debug("Getting VM CONSOLE from VIM")
2748
2749         try:
2750             self._reload_connection()
2751             server = self.nova.servers.find(id=vm_id)
2752
2753             if console_type is None or console_type == "novnc":
2754                 console_dict = server.get_vnc_console("novnc")
2755             elif console_type == "xvpvnc":
2756                 console_dict = server.get_vnc_console(console_type)
2757             elif console_type == "rdp-html5":
2758                 console_dict = server.get_rdp_console(console_type)
2759             elif console_type == "spice-html5":
2760                 console_dict = server.get_spice_console(console_type)
2761             else:
2762                 raise vimconn.VimConnException(
2763                     "console type '{}' not allowed".format(console_type),
2764                     http_code=vimconn.HTTP_Bad_Request,
2765                 )
2766
2767             console_dict1 = console_dict.get("console")
2768
2769             if console_dict1:
2770                 console_url = console_dict1.get("url")
2771
2772                 if console_url:
2773                     # parse console_url
2774                     protocol_index = console_url.find("//")
2775                     suffix_index = (
2776                         console_url[protocol_index + 2 :].find("/") + protocol_index + 2
2777                     )
2778                     port_index = (
2779                         console_url[protocol_index + 2 : suffix_index].find(":")
2780                         + protocol_index
2781                         + 2
2782                     )
2783
2784                     if protocol_index < 0 or port_index < 0 or suffix_index < 0:
2785                         return (
2786                             -vimconn.HTTP_Internal_Server_Error,
2787                             "Unexpected response from VIM",
2788                         )
2789
2790                     console_dict = {
2791                         "protocol": console_url[0:protocol_index],
2792                         "server": console_url[protocol_index + 2 : port_index],
2793                         "port": console_url[port_index:suffix_index],
2794                         "suffix": console_url[suffix_index + 1 :],
2795                     }
2796                     protocol_index += 2
2797
2798                     return console_dict
2799             raise vimconn.VimConnUnexpectedResponse("Unexpected response from VIM")
2800         except (
2801             nvExceptions.NotFound,
2802             ksExceptions.ClientException,
2803             nvExceptions.ClientException,
2804             nvExceptions.BadRequest,
2805             ConnectionError,
2806         ) as e:
2807             self._format_exception(e)
2808
2809     def _delete_ports_by_id_wth_neutron(self, k_id: str) -> None:
2810         """Neutron delete ports by id.
2811         Args:
2812             k_id    (str):      Port id in the VIM
2813         """
2814         try:
2815             port_dict = self.neutron.list_ports()
2816             existing_ports = [port["id"] for port in port_dict["ports"] if port_dict]
2817
2818             if k_id in existing_ports:
2819                 self.neutron.delete_port(k_id)
2820
2821         except Exception as e:
2822             self.logger.error("Error deleting port: {}: {}".format(type(e).__name__, e))
2823
2824     def _delete_volumes_by_id_wth_cinder(
2825         self, k: str, k_id: str, volumes_to_hold: list, created_items: dict
2826     ) -> bool:
2827         """Cinder delete volume by id.
2828         Args:
2829             k   (str):                      Full item name in created_items
2830             k_id    (str):                  ID of floating ip in VIM
2831             volumes_to_hold (list):          Volumes not to delete
2832             created_items   (dict):         All created items belongs to VM
2833         """
2834         try:
2835             if k_id in volumes_to_hold:
2836                 return
2837
2838             if self.cinder.volumes.get(k_id).status != "available":
2839                 return True
2840
2841             else:
2842                 self.cinder.volumes.delete(k_id)
2843                 created_items[k] = None
2844
2845         except Exception as e:
2846             self.logger.error(
2847                 "Error deleting volume: {}: {}".format(type(e).__name__, e)
2848             )
2849
2850     def _delete_floating_ip_by_id(self, k: str, k_id: str, created_items: dict) -> None:
2851         """Neutron delete floating ip by id.
2852         Args:
2853             k   (str):                      Full item name in created_items
2854             k_id    (str):                  ID of floating ip in VIM
2855             created_items   (dict):         All created items belongs to VM
2856         """
2857         try:
2858             self.neutron.delete_floatingip(k_id)
2859             created_items[k] = None
2860
2861         except Exception as e:
2862             self.logger.error(
2863                 "Error deleting floating ip: {}: {}".format(type(e).__name__, e)
2864             )
2865
2866     @staticmethod
2867     def _get_item_name_id(k: str) -> Tuple[str, str]:
2868         k_item, _, k_id = k.partition(":")
2869         return k_item, k_id
2870
2871     def _delete_vm_ports_attached_to_network(self, created_items: dict) -> None:
2872         """Delete VM ports attached to the networks before deleting virtual machine.
2873         Args:
2874             created_items   (dict):     All created items belongs to VM
2875         """
2876
2877         for k, v in created_items.items():
2878             if not v:  # skip already deleted
2879                 continue
2880
2881             try:
2882                 k_item, k_id = self._get_item_name_id(k)
2883                 if k_item == "port":
2884                     self._delete_ports_by_id_wth_neutron(k_id)
2885
2886             except Exception as e:
2887                 self.logger.error(
2888                     "Error deleting port: {}: {}".format(type(e).__name__, e)
2889                 )
2890
2891     def _delete_created_items(
2892         self, created_items: dict, volumes_to_hold: list, keep_waiting: bool
2893     ) -> bool:
2894         """Delete Volumes and floating ip if they exist in created_items."""
2895         for k, v in created_items.items():
2896             if not v:  # skip already deleted
2897                 continue
2898
2899             try:
2900                 k_item, k_id = self._get_item_name_id(k)
2901
2902                 if k_item == "volume":
2903                     unavailable_vol = self._delete_volumes_by_id_wth_cinder(
2904                         k, k_id, volumes_to_hold, created_items
2905                     )
2906
2907                     if unavailable_vol:
2908                         keep_waiting = True
2909
2910                 elif k_item == "floating_ip":
2911                     self._delete_floating_ip_by_id(k, k_id, created_items)
2912
2913             except Exception as e:
2914                 self.logger.error("Error deleting {}: {}".format(k, e))
2915
2916         return keep_waiting
2917
2918     def delete_vminstance(
2919         self, vm_id: str, created_items: dict = None, volumes_to_hold: list = None
2920     ) -> None:
2921         """Removes a VM instance from VIM. Returns the old identifier.
2922         Args:
2923             vm_id   (str):              Identifier of VM instance
2924             created_items   (dict):     All created items belongs to VM
2925             volumes_to_hold (list):     Volumes_to_hold
2926         """
2927         if created_items is None:
2928             created_items = {}
2929         if volumes_to_hold is None:
2930             volumes_to_hold = []
2931
2932         try:
2933             self._reload_connection()
2934
2935             # Delete VM ports attached to the networks before the virtual machine
2936             if created_items:
2937                 self._delete_vm_ports_attached_to_network(created_items)
2938
2939             if vm_id:
2940                 self.nova.servers.delete(vm_id)
2941
2942             # Although having detached, volumes should have in active status before deleting.
2943             # We ensure in this loop
2944             keep_waiting = True
2945             elapsed_time = 0
2946
2947             while keep_waiting and elapsed_time < volume_timeout:
2948                 keep_waiting = False
2949
2950                 # Delete volumes and floating IP.
2951                 keep_waiting = self._delete_created_items(
2952                     created_items, volumes_to_hold, keep_waiting
2953                 )
2954
2955                 if keep_waiting:
2956                     time.sleep(1)
2957                     elapsed_time += 1
2958
2959         except (
2960             nvExceptions.NotFound,
2961             ksExceptions.ClientException,
2962             nvExceptions.ClientException,
2963             ConnectionError,
2964         ) as e:
2965             self._format_exception(e)
2966
2967     def refresh_vms_status(self, vm_list):
2968         """Get the status of the virtual machines and their interfaces/ports
2969         Params: the list of VM identifiers
2970         Returns a dictionary with:
2971             vm_id:          #VIM id of this Virtual Machine
2972                 status:     #Mandatory. Text with one of:
2973                             #  DELETED (not found at vim)
2974                             #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
2975                             #  OTHER (Vim reported other status not understood)
2976                             #  ERROR (VIM indicates an ERROR status)
2977                             #  ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
2978                             #  CREATING (on building process), ERROR
2979                             #  ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
2980                             #
2981                 error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
2982                 vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
2983                 interfaces:
2984                  -  vim_info:         #Text with plain information obtained from vim (yaml.safe_dump)
2985                     mac_address:      #Text format XX:XX:XX:XX:XX:XX
2986                     vim_net_id:       #network id where this interface is connected
2987                     vim_interface_id: #interface/port VIM id
2988                     ip_address:       #null, or text with IPv4, IPv6 address
2989                     compute_node:     #identification of compute node where PF,VF interface is allocated
2990                     pci:              #PCI address of the NIC that hosts the PF,VF
2991                     vlan:             #physical VLAN used for VF
2992         """
2993         vm_dict = {}
2994         self.logger.debug(
2995             "refresh_vms status: Getting tenant VM instance information from VIM"
2996         )
2997
2998         for vm_id in vm_list:
2999             vm = {}
3000
3001             try:
3002                 vm_vim = self.get_vminstance(vm_id)
3003
3004                 if vm_vim["status"] in vmStatus2manoFormat:
3005                     vm["status"] = vmStatus2manoFormat[vm_vim["status"]]
3006                 else:
3007                     vm["status"] = "OTHER"
3008                     vm["error_msg"] = "VIM status reported " + vm_vim["status"]
3009
3010                 vm_vim.pop("OS-EXT-SRV-ATTR:user_data", None)
3011                 vm_vim.pop("user_data", None)
3012                 vm["vim_info"] = self.serialize(vm_vim)
3013
3014                 vm["interfaces"] = []
3015                 if vm_vim.get("fault"):
3016                     vm["error_msg"] = str(vm_vim["fault"])
3017
3018                 # get interfaces
3019                 try:
3020                     self._reload_connection()
3021                     port_dict = self.neutron.list_ports(device_id=vm_id)
3022
3023                     for port in port_dict["ports"]:
3024                         interface = {}
3025                         interface["vim_info"] = self.serialize(port)
3026                         interface["mac_address"] = port.get("mac_address")
3027                         interface["vim_net_id"] = port["network_id"]
3028                         interface["vim_interface_id"] = port["id"]
3029                         # check if OS-EXT-SRV-ATTR:host is there,
3030                         # in case of non-admin credentials, it will be missing
3031
3032                         if vm_vim.get("OS-EXT-SRV-ATTR:host"):
3033                             interface["compute_node"] = vm_vim["OS-EXT-SRV-ATTR:host"]
3034
3035                         interface["pci"] = None
3036
3037                         # check if binding:profile is there,
3038                         # in case of non-admin credentials, it will be missing
3039                         if port.get("binding:profile"):
3040                             if port["binding:profile"].get("pci_slot"):
3041                                 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting
3042                                 #  the slot to 0x00
3043                                 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
3044                                 #   CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2)   assuming there are 2 ports per nic
3045                                 pci = port["binding:profile"]["pci_slot"]
3046                                 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
3047                                 interface["pci"] = pci
3048
3049                         interface["vlan"] = None
3050
3051                         if port.get("binding:vif_details"):
3052                             interface["vlan"] = port["binding:vif_details"].get("vlan")
3053
3054                         # Get vlan from network in case not present in port for those old openstacks and cases where
3055                         # it is needed vlan at PT
3056                         if not interface["vlan"]:
3057                             # if network is of type vlan and port is of type direct (sr-iov) then set vlan id
3058                             network = self.neutron.show_network(port["network_id"])
3059
3060                             if (
3061                                 network["network"].get("provider:network_type")
3062                                 == "vlan"
3063                             ):
3064                                 # and port.get("binding:vnic_type") in ("direct", "direct-physical"):
3065                                 interface["vlan"] = network["network"].get(
3066                                     "provider:segmentation_id"
3067                                 )
3068
3069                         ips = []
3070                         # look for floating ip address
3071                         try:
3072                             floating_ip_dict = self.neutron.list_floatingips(
3073                                 port_id=port["id"]
3074                             )
3075
3076                             if floating_ip_dict.get("floatingips"):
3077                                 ips.append(
3078                                     floating_ip_dict["floatingips"][0].get(
3079                                         "floating_ip_address"
3080                                     )
3081                                 )
3082                         except Exception:
3083                             pass
3084
3085                         for subnet in port["fixed_ips"]:
3086                             ips.append(subnet["ip_address"])
3087
3088                         interface["ip_address"] = ";".join(ips)
3089                         vm["interfaces"].append(interface)
3090                 except Exception as e:
3091                     self.logger.error(
3092                         "Error getting vm interface information {}: {}".format(
3093                             type(e).__name__, e
3094                         ),
3095                         exc_info=True,
3096                     )
3097             except vimconn.VimConnNotFoundException as e:
3098                 self.logger.error("Exception getting vm status: %s", str(e))
3099                 vm["status"] = "DELETED"
3100                 vm["error_msg"] = str(e)
3101             except vimconn.VimConnException as e:
3102                 self.logger.error("Exception getting vm status: %s", str(e))
3103                 vm["status"] = "VIM_ERROR"
3104                 vm["error_msg"] = str(e)
3105
3106             vm_dict[vm_id] = vm
3107
3108         return vm_dict
3109
3110     def action_vminstance(self, vm_id, action_dict, created_items={}):
3111         """Send and action over a VM instance from VIM
3112         Returns None or the console dict if the action was successfully sent to the VIM
3113         """
3114         self.logger.debug("Action over VM '%s': %s", vm_id, str(action_dict))
3115
3116         try:
3117             self._reload_connection()
3118             server = self.nova.servers.find(id=vm_id)
3119
3120             if "start" in action_dict:
3121                 if action_dict["start"] == "rebuild":
3122                     server.rebuild()
3123                 else:
3124                     if server.status == "PAUSED":
3125                         server.unpause()
3126                     elif server.status == "SUSPENDED":
3127                         server.resume()
3128                     elif server.status == "SHUTOFF":
3129                         server.start()
3130                     else:
3131                         self.logger.debug(
3132                             "ERROR : Instance is not in SHUTOFF/PAUSE/SUSPEND state"
3133                         )
3134                         raise vimconn.VimConnException(
3135                             "Cannot 'start' instance while it is in active state",
3136                             http_code=vimconn.HTTP_Bad_Request,
3137                         )
3138
3139             elif "pause" in action_dict:
3140                 server.pause()
3141             elif "resume" in action_dict:
3142                 server.resume()
3143             elif "shutoff" in action_dict or "shutdown" in action_dict:
3144                 self.logger.debug("server status %s", server.status)
3145                 if server.status == "ACTIVE":
3146                     server.stop()
3147                 else:
3148                     self.logger.debug("ERROR: VM is not in Active state")
3149                     raise vimconn.VimConnException(
3150                         "VM is not in active state, stop operation is not allowed",
3151                         http_code=vimconn.HTTP_Bad_Request,
3152                     )
3153             elif "forceOff" in action_dict:
3154                 server.stop()  # TODO
3155             elif "terminate" in action_dict:
3156                 server.delete()
3157             elif "createImage" in action_dict:
3158                 server.create_image()
3159                 # "path":path_schema,
3160                 # "description":description_schema,
3161                 # "name":name_schema,
3162                 # "metadata":metadata_schema,
3163                 # "imageRef": id_schema,
3164                 # "disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
3165             elif "rebuild" in action_dict:
3166                 server.rebuild(server.image["id"])
3167             elif "reboot" in action_dict:
3168                 server.reboot()  # reboot_type="SOFT"
3169             elif "console" in action_dict:
3170                 console_type = action_dict["console"]
3171
3172                 if console_type is None or console_type == "novnc":
3173                     console_dict = server.get_vnc_console("novnc")
3174                 elif console_type == "xvpvnc":
3175                     console_dict = server.get_vnc_console(console_type)
3176                 elif console_type == "rdp-html5":
3177                     console_dict = server.get_rdp_console(console_type)
3178                 elif console_type == "spice-html5":
3179                     console_dict = server.get_spice_console(console_type)
3180                 else:
3181                     raise vimconn.VimConnException(
3182                         "console type '{}' not allowed".format(console_type),
3183                         http_code=vimconn.HTTP_Bad_Request,
3184                     )
3185
3186                 try:
3187                     console_url = console_dict["console"]["url"]
3188                     # parse console_url
3189                     protocol_index = console_url.find("//")
3190                     suffix_index = (
3191                         console_url[protocol_index + 2 :].find("/") + protocol_index + 2
3192                     )
3193                     port_index = (
3194                         console_url[protocol_index + 2 : suffix_index].find(":")
3195                         + protocol_index
3196                         + 2
3197                     )
3198
3199                     if protocol_index < 0 or port_index < 0 or suffix_index < 0:
3200                         raise vimconn.VimConnException(
3201                             "Unexpected response from VIM " + str(console_dict)
3202                         )
3203
3204                     console_dict2 = {
3205                         "protocol": console_url[0:protocol_index],
3206                         "server": console_url[protocol_index + 2 : port_index],
3207                         "port": int(console_url[port_index + 1 : suffix_index]),
3208                         "suffix": console_url[suffix_index + 1 :],
3209                     }
3210
3211                     return console_dict2
3212                 except Exception:
3213                     raise vimconn.VimConnException(
3214                         "Unexpected response from VIM " + str(console_dict)
3215                     )
3216
3217             return None
3218         except (
3219             ksExceptions.ClientException,
3220             nvExceptions.ClientException,
3221             nvExceptions.NotFound,
3222             ConnectionError,
3223         ) as e:
3224             self._format_exception(e)
3225         # TODO insert exception vimconn.HTTP_Unauthorized
3226
3227     # ###### VIO Specific Changes #########
3228     def _generate_vlanID(self):
3229         """
3230         Method to get unused vlanID
3231             Args:
3232                 None
3233             Returns:
3234                 vlanID
3235         """
3236         # Get used VLAN IDs
3237         usedVlanIDs = []
3238         networks = self.get_network_list()
3239
3240         for net in networks:
3241             if net.get("provider:segmentation_id"):
3242                 usedVlanIDs.append(net.get("provider:segmentation_id"))
3243
3244         used_vlanIDs = set(usedVlanIDs)
3245
3246         # find unused VLAN ID
3247         for vlanID_range in self.config.get("dataplane_net_vlan_range"):
3248             try:
3249                 start_vlanid, end_vlanid = map(
3250                     int, vlanID_range.replace(" ", "").split("-")
3251                 )
3252
3253                 for vlanID in range(start_vlanid, end_vlanid + 1):
3254                     if vlanID not in used_vlanIDs:
3255                         return vlanID
3256             except Exception as exp:
3257                 raise vimconn.VimConnException(
3258                     "Exception {} occurred while generating VLAN ID.".format(exp)
3259                 )
3260         else:
3261             raise vimconn.VimConnConflictException(
3262                 "Unable to create the SRIOV VLAN network. All given Vlan IDs {} are in use.".format(
3263                     self.config.get("dataplane_net_vlan_range")
3264                 )
3265             )
3266
3267     def _generate_multisegment_vlanID(self):
3268         """
3269         Method to get unused vlanID
3270         Args:
3271             None
3272         Returns:
3273             vlanID
3274         """
3275         # Get used VLAN IDs
3276         usedVlanIDs = []
3277         networks = self.get_network_list()
3278         for net in networks:
3279             if net.get("provider:network_type") == "vlan" and net.get(
3280                 "provider:segmentation_id"
3281             ):
3282                 usedVlanIDs.append(net.get("provider:segmentation_id"))
3283             elif net.get("segments"):
3284                 for segment in net.get("segments"):
3285                     if segment.get("provider:network_type") == "vlan" and segment.get(
3286                         "provider:segmentation_id"
3287                     ):
3288                         usedVlanIDs.append(segment.get("provider:segmentation_id"))
3289
3290         used_vlanIDs = set(usedVlanIDs)
3291
3292         # find unused VLAN ID
3293         for vlanID_range in self.config.get("multisegment_vlan_range"):
3294             try:
3295                 start_vlanid, end_vlanid = map(
3296                     int, vlanID_range.replace(" ", "").split("-")
3297                 )
3298
3299                 for vlanID in range(start_vlanid, end_vlanid + 1):
3300                     if vlanID not in used_vlanIDs:
3301                         return vlanID
3302             except Exception as exp:
3303                 raise vimconn.VimConnException(
3304                     "Exception {} occurred while generating VLAN ID.".format(exp)
3305                 )
3306         else:
3307             raise vimconn.VimConnConflictException(
3308                 "Unable to create the VLAN segment. All VLAN IDs {} are in use.".format(
3309                     self.config.get("multisegment_vlan_range")
3310                 )
3311             )
3312
3313     def _validate_vlan_ranges(self, input_vlan_range, text_vlan_range):
3314         """
3315         Method to validate user given vlanID ranges
3316             Args:  None
3317             Returns: None
3318         """
3319         for vlanID_range in input_vlan_range:
3320             vlan_range = vlanID_range.replace(" ", "")
3321             # validate format
3322             vlanID_pattern = r"(\d)*-(\d)*$"
3323             match_obj = re.match(vlanID_pattern, vlan_range)
3324             if not match_obj:
3325                 raise vimconn.VimConnConflictException(
3326                     "Invalid VLAN range for {}: {}.You must provide "
3327                     "'{}' in format [start_ID - end_ID].".format(
3328                         text_vlan_range, vlanID_range, text_vlan_range
3329                     )
3330                 )
3331
3332             start_vlanid, end_vlanid = map(int, vlan_range.split("-"))
3333             if start_vlanid <= 0:
3334                 raise vimconn.VimConnConflictException(
3335                     "Invalid VLAN range for {}: {}. Start ID can not be zero. For VLAN "
3336                     "networks valid IDs are 1 to 4094 ".format(
3337                         text_vlan_range, vlanID_range
3338                     )
3339                 )
3340
3341             if end_vlanid > 4094:
3342                 raise vimconn.VimConnConflictException(
3343                     "Invalid VLAN range for {}: {}. End VLAN ID can not be "
3344                     "greater than 4094. For VLAN networks valid IDs are 1 to 4094 ".format(
3345                         text_vlan_range, vlanID_range
3346                     )
3347                 )
3348
3349             if start_vlanid > end_vlanid:
3350                 raise vimconn.VimConnConflictException(
3351                     "Invalid VLAN range for {}: {}. You must provide '{}'"
3352                     " in format start_ID - end_ID and start_ID < end_ID ".format(
3353                         text_vlan_range, vlanID_range, text_vlan_range
3354                     )
3355                 )
3356
3357     # NOT USED FUNCTIONS
3358
3359     def new_external_port(self, port_data):
3360         """Adds a external port to VIM
3361         Returns the port identifier"""
3362         # TODO openstack if needed
3363         return (
3364             -vimconn.HTTP_Internal_Server_Error,
3365             "osconnector.new_external_port() not implemented",
3366         )
3367
3368     def connect_port_network(self, port_id, network_id, admin=False):
3369         """Connects a external port to a network
3370         Returns status code of the VIM response"""
3371         # TODO openstack if needed
3372         return (
3373             -vimconn.HTTP_Internal_Server_Error,
3374             "osconnector.connect_port_network() not implemented",
3375         )
3376
3377     def new_user(self, user_name, user_passwd, tenant_id=None):
3378         """Adds a new user to openstack VIM
3379         Returns the user identifier"""
3380         self.logger.debug("osconnector: Adding a new user to VIM")
3381
3382         try:
3383             self._reload_connection()
3384             user = self.keystone.users.create(
3385                 user_name, password=user_passwd, default_project=tenant_id
3386             )
3387             # self.keystone.tenants.add_user(self.k_creds["username"], #role)
3388
3389             return user.id
3390         except ksExceptions.ConnectionError as e:
3391             error_value = -vimconn.HTTP_Bad_Request
3392             error_text = (
3393                 type(e).__name__
3394                 + ": "
3395                 + (str(e) if len(e.args) == 0 else str(e.args[0]))
3396             )
3397         except ksExceptions.ClientException as e:  # TODO remove
3398             error_value = -vimconn.HTTP_Bad_Request
3399             error_text = (
3400                 type(e).__name__
3401                 + ": "
3402                 + (str(e) if len(e.args) == 0 else str(e.args[0]))
3403             )
3404
3405         # TODO insert exception vimconn.HTTP_Unauthorized
3406         # if reaching here is because an exception
3407         self.logger.debug("new_user " + error_text)
3408
3409         return error_value, error_text
3410
3411     def delete_user(self, user_id):
3412         """Delete a user from openstack VIM
3413         Returns the user identifier"""
3414         if self.debug:
3415             print("osconnector: Deleting  a  user from VIM")
3416
3417         try:
3418             self._reload_connection()
3419             self.keystone.users.delete(user_id)
3420
3421             return 1, user_id
3422         except ksExceptions.ConnectionError as e:
3423             error_value = -vimconn.HTTP_Bad_Request
3424             error_text = (
3425                 type(e).__name__
3426                 + ": "
3427                 + (str(e) if len(e.args) == 0 else str(e.args[0]))
3428             )
3429         except ksExceptions.NotFound as e:
3430             error_value = -vimconn.HTTP_Not_Found
3431             error_text = (
3432                 type(e).__name__
3433                 + ": "
3434                 + (str(e) if len(e.args) == 0 else str(e.args[0]))
3435             )
3436         except ksExceptions.ClientException as e:  # TODO remove
3437             error_value = -vimconn.HTTP_Bad_Request
3438             error_text = (
3439                 type(e).__name__
3440                 + ": "
3441                 + (str(e) if len(e.args) == 0 else str(e.args[0]))
3442             )
3443
3444         # TODO insert exception vimconn.HTTP_Unauthorized
3445         # if reaching here is because an exception
3446         self.logger.debug("delete_tenant " + error_text)
3447
3448         return error_value, error_text
3449
3450     def get_hosts_info(self):
3451         """Get the information of deployed hosts
3452         Returns the hosts content"""
3453         if self.debug:
3454             print("osconnector: Getting Host info from VIM")
3455
3456         try:
3457             h_list = []
3458             self._reload_connection()
3459             hypervisors = self.nova.hypervisors.list()
3460
3461             for hype in hypervisors:
3462                 h_list.append(hype.to_dict())
3463
3464             return 1, {"hosts": h_list}
3465         except nvExceptions.NotFound as e:
3466             error_value = -vimconn.HTTP_Not_Found
3467             error_text = str(e) if len(e.args) == 0 else str(e.args[0])
3468         except (ksExceptions.ClientException, nvExceptions.ClientException) as e:
3469             error_value = -vimconn.HTTP_Bad_Request
3470             error_text = (
3471                 type(e).__name__
3472                 + ": "
3473                 + (str(e) if len(e.args) == 0 else str(e.args[0]))
3474             )
3475
3476         # TODO insert exception vimconn.HTTP_Unauthorized
3477         # if reaching here is because an exception
3478         self.logger.debug("get_hosts_info " + error_text)
3479
3480         return error_value, error_text
3481
3482     def get_hosts(self, vim_tenant):
3483         """Get the hosts and deployed instances
3484         Returns the hosts content"""
3485         r, hype_dict = self.get_hosts_info()
3486
3487         if r < 0:
3488             return r, hype_dict
3489
3490         hypervisors = hype_dict["hosts"]
3491
3492         try:
3493             servers = self.nova.servers.list()
3494             for hype in hypervisors:
3495                 for server in servers:
3496                     if (
3497                         server.to_dict()["OS-EXT-SRV-ATTR:hypervisor_hostname"]
3498                         == hype["hypervisor_hostname"]
3499                     ):
3500                         if "vm" in hype:
3501                             hype["vm"].append(server.id)
3502                         else:
3503                             hype["vm"] = [server.id]
3504
3505             return 1, hype_dict
3506         except nvExceptions.NotFound as e:
3507             error_value = -vimconn.HTTP_Not_Found
3508             error_text = str(e) if len(e.args) == 0 else str(e.args[0])
3509         except (ksExceptions.ClientException, nvExceptions.ClientException) as e:
3510             error_value = -vimconn.HTTP_Bad_Request
3511             error_text = (
3512                 type(e).__name__
3513                 + ": "
3514                 + (str(e) if len(e.args) == 0 else str(e.args[0]))
3515             )
3516
3517         # TODO insert exception vimconn.HTTP_Unauthorized
3518         # if reaching here is because an exception
3519         self.logger.debug("get_hosts " + error_text)
3520
3521         return error_value, error_text
3522
3523     def new_classification(self, name, ctype, definition):
3524         self.logger.debug(
3525             "Adding a new (Traffic) Classification to VIM, named %s", name
3526         )
3527
3528         try:
3529             new_class = None
3530             self._reload_connection()
3531
3532             if ctype not in supportedClassificationTypes:
3533                 raise vimconn.VimConnNotSupportedException(
3534                     "OpenStack VIM connector does not support provided "
3535                     "Classification Type {}, supported ones are: {}".format(
3536                         ctype, supportedClassificationTypes
3537                     )
3538                 )
3539
3540             if not self._validate_classification(ctype, definition):
3541                 raise vimconn.VimConnException(
3542                     "Incorrect Classification definition for the type specified."
3543                 )
3544
3545             classification_dict = definition
3546             classification_dict["name"] = name
3547             new_class = self.neutron.create_sfc_flow_classifier(
3548                 {"flow_classifier": classification_dict}
3549             )
3550
3551             return new_class["flow_classifier"]["id"]
3552         except (
3553             neExceptions.ConnectionFailed,
3554             ksExceptions.ClientException,
3555             neExceptions.NeutronException,
3556             ConnectionError,
3557         ) as e:
3558             self.logger.error("Creation of Classification failed.")
3559             self._format_exception(e)
3560
3561     def get_classification(self, class_id):
3562         self.logger.debug(" Getting Classification %s from VIM", class_id)
3563         filter_dict = {"id": class_id}
3564         class_list = self.get_classification_list(filter_dict)
3565
3566         if len(class_list) == 0:
3567             raise vimconn.VimConnNotFoundException(
3568                 "Classification '{}' not found".format(class_id)
3569             )
3570         elif len(class_list) > 1:
3571             raise vimconn.VimConnConflictException(
3572                 "Found more than one Classification with this criteria"
3573             )
3574
3575         classification = class_list[0]
3576
3577         return classification
3578
3579     def get_classification_list(self, filter_dict={}):
3580         self.logger.debug(
3581             "Getting Classifications from VIM filter: '%s'", str(filter_dict)
3582         )
3583
3584         try:
3585             filter_dict_os = filter_dict.copy()
3586             self._reload_connection()
3587
3588             if self.api_version3 and "tenant_id" in filter_dict_os:
3589                 filter_dict_os["project_id"] = filter_dict_os.pop("tenant_id")
3590
3591             classification_dict = self.neutron.list_sfc_flow_classifiers(
3592                 **filter_dict_os
3593             )
3594             classification_list = classification_dict["flow_classifiers"]
3595             self.__classification_os2mano(classification_list)
3596
3597             return classification_list
3598         except (
3599             neExceptions.ConnectionFailed,
3600             ksExceptions.ClientException,
3601             neExceptions.NeutronException,
3602             ConnectionError,
3603         ) as e:
3604             self._format_exception(e)
3605
3606     def delete_classification(self, class_id):
3607         self.logger.debug("Deleting Classification '%s' from VIM", class_id)
3608
3609         try:
3610             self._reload_connection()
3611             self.neutron.delete_sfc_flow_classifier(class_id)
3612
3613             return class_id
3614         except (
3615             neExceptions.ConnectionFailed,
3616             neExceptions.NeutronException,
3617             ksExceptions.ClientException,
3618             neExceptions.NeutronException,
3619             ConnectionError,
3620         ) as e:
3621             self._format_exception(e)
3622
3623     def new_sfi(self, name, ingress_ports, egress_ports, sfc_encap=True):
3624         self.logger.debug(
3625             "Adding a new Service Function Instance to VIM, named '%s'", name
3626         )
3627
3628         try:
3629             new_sfi = None
3630             self._reload_connection()
3631             correlation = None
3632
3633             if sfc_encap:
3634                 correlation = "nsh"
3635
3636             if len(ingress_ports) != 1:
3637                 raise vimconn.VimConnNotSupportedException(
3638                     "OpenStack VIM connector can only have 1 ingress port per SFI"
3639                 )
3640
3641             if len(egress_ports) != 1:
3642                 raise vimconn.VimConnNotSupportedException(
3643                     "OpenStack VIM connector can only have 1 egress port per SFI"
3644                 )
3645
3646             sfi_dict = {
3647                 "name": name,
3648                 "ingress": ingress_ports[0],
3649                 "egress": egress_ports[0],
3650                 "service_function_parameters": {"correlation": correlation},
3651             }
3652             new_sfi = self.neutron.create_sfc_port_pair({"port_pair": sfi_dict})
3653
3654             return new_sfi["port_pair"]["id"]
3655         except (
3656             neExceptions.ConnectionFailed,
3657             ksExceptions.ClientException,
3658             neExceptions.NeutronException,
3659             ConnectionError,
3660         ) as e:
3661             if new_sfi:
3662                 try:
3663                     self.neutron.delete_sfc_port_pair(new_sfi["port_pair"]["id"])
3664                 except Exception:
3665                     self.logger.error(
3666                         "Creation of Service Function Instance failed, with "
3667                         "subsequent deletion failure as well."
3668                     )
3669
3670             self._format_exception(e)
3671
3672     def get_sfi(self, sfi_id):
3673         self.logger.debug("Getting Service Function Instance %s from VIM", sfi_id)
3674         filter_dict = {"id": sfi_id}
3675         sfi_list = self.get_sfi_list(filter_dict)
3676
3677         if len(sfi_list) == 0:
3678             raise vimconn.VimConnNotFoundException(
3679                 "Service Function Instance '{}' not found".format(sfi_id)
3680             )
3681         elif len(sfi_list) > 1:
3682             raise vimconn.VimConnConflictException(
3683                 "Found more than one Service Function Instance with this criteria"
3684             )
3685
3686         sfi = sfi_list[0]
3687
3688         return sfi
3689
3690     def get_sfi_list(self, filter_dict={}):
3691         self.logger.debug(
3692             "Getting Service Function Instances from VIM filter: '%s'", str(filter_dict)
3693         )
3694
3695         try:
3696             self._reload_connection()
3697             filter_dict_os = filter_dict.copy()
3698
3699             if self.api_version3 and "tenant_id" in filter_dict_os:
3700                 filter_dict_os["project_id"] = filter_dict_os.pop("tenant_id")
3701
3702             sfi_dict = self.neutron.list_sfc_port_pairs(**filter_dict_os)
3703             sfi_list = sfi_dict["port_pairs"]
3704             self.__sfi_os2mano(sfi_list)
3705
3706             return sfi_list
3707         except (
3708             neExceptions.ConnectionFailed,
3709             ksExceptions.ClientException,
3710             neExceptions.NeutronException,
3711             ConnectionError,
3712         ) as e:
3713             self._format_exception(e)
3714
3715     def delete_sfi(self, sfi_id):
3716         self.logger.debug("Deleting Service Function Instance '%s' from VIM", sfi_id)
3717
3718         try:
3719             self._reload_connection()
3720             self.neutron.delete_sfc_port_pair(sfi_id)
3721
3722             return sfi_id
3723         except (
3724             neExceptions.ConnectionFailed,
3725             neExceptions.NeutronException,
3726             ksExceptions.ClientException,
3727             neExceptions.NeutronException,
3728             ConnectionError,
3729         ) as e:
3730             self._format_exception(e)
3731
3732     def new_sf(self, name, sfis, sfc_encap=True):
3733         self.logger.debug("Adding a new Service Function to VIM, named '%s'", name)
3734
3735         try:
3736             new_sf = None
3737             self._reload_connection()
3738             # correlation = None
3739             # if sfc_encap:
3740             #     correlation = "nsh"
3741
3742             for instance in sfis:
3743                 sfi = self.get_sfi(instance)
3744
3745                 if sfi.get("sfc_encap") != sfc_encap:
3746                     raise vimconn.VimConnNotSupportedException(
3747                         "OpenStack VIM connector requires all SFIs of the "
3748                         "same SF to share the same SFC Encapsulation"
3749                     )
3750
3751             sf_dict = {"name": name, "port_pairs": sfis}
3752             new_sf = self.neutron.create_sfc_port_pair_group(
3753                 {"port_pair_group": sf_dict}
3754             )
3755
3756             return new_sf["port_pair_group"]["id"]
3757         except (
3758             neExceptions.ConnectionFailed,
3759             ksExceptions.ClientException,
3760             neExceptions.NeutronException,
3761             ConnectionError,
3762         ) as e:
3763             if new_sf:
3764                 try:
3765                     self.neutron.delete_sfc_port_pair_group(
3766                         new_sf["port_pair_group"]["id"]
3767                     )
3768                 except Exception:
3769                     self.logger.error(
3770                         "Creation of Service Function failed, with "
3771                         "subsequent deletion failure as well."
3772                     )
3773
3774             self._format_exception(e)
3775
3776     def get_sf(self, sf_id):
3777         self.logger.debug("Getting Service Function %s from VIM", sf_id)
3778         filter_dict = {"id": sf_id}
3779         sf_list = self.get_sf_list(filter_dict)
3780
3781         if len(sf_list) == 0:
3782             raise vimconn.VimConnNotFoundException(
3783                 "Service Function '{}' not found".format(sf_id)
3784             )
3785         elif len(sf_list) > 1:
3786             raise vimconn.VimConnConflictException(
3787                 "Found more than one Service Function with this criteria"
3788             )
3789
3790         sf = sf_list[0]
3791
3792         return sf
3793
3794     def get_sf_list(self, filter_dict={}):
3795         self.logger.debug(
3796             "Getting Service Function from VIM filter: '%s'", str(filter_dict)
3797         )
3798
3799         try:
3800             self._reload_connection()
3801             filter_dict_os = filter_dict.copy()
3802
3803             if self.api_version3 and "tenant_id" in filter_dict_os:
3804                 filter_dict_os["project_id"] = filter_dict_os.pop("tenant_id")
3805
3806             sf_dict = self.neutron.list_sfc_port_pair_groups(**filter_dict_os)
3807             sf_list = sf_dict["port_pair_groups"]
3808             self.__sf_os2mano(sf_list)
3809
3810             return sf_list
3811         except (
3812             neExceptions.ConnectionFailed,
3813             ksExceptions.ClientException,
3814             neExceptions.NeutronException,
3815             ConnectionError,
3816         ) as e:
3817             self._format_exception(e)
3818
3819     def delete_sf(self, sf_id):
3820         self.logger.debug("Deleting Service Function '%s' from VIM", sf_id)
3821
3822         try:
3823             self._reload_connection()
3824             self.neutron.delete_sfc_port_pair_group(sf_id)
3825
3826             return sf_id
3827         except (
3828             neExceptions.ConnectionFailed,
3829             neExceptions.NeutronException,
3830             ksExceptions.ClientException,
3831             neExceptions.NeutronException,
3832             ConnectionError,
3833         ) as e:
3834             self._format_exception(e)
3835
3836     def new_sfp(self, name, classifications, sfs, sfc_encap=True, spi=None):
3837         self.logger.debug("Adding a new Service Function Path to VIM, named '%s'", name)
3838
3839         try:
3840             new_sfp = None
3841             self._reload_connection()
3842             # In networking-sfc the MPLS encapsulation is legacy
3843             # should be used when no full SFC Encapsulation is intended
3844             correlation = "mpls"
3845
3846             if sfc_encap:
3847                 correlation = "nsh"
3848
3849             sfp_dict = {
3850                 "name": name,
3851                 "flow_classifiers": classifications,
3852                 "port_pair_groups": sfs,
3853                 "chain_parameters": {"correlation": correlation},
3854             }
3855
3856             if spi:
3857                 sfp_dict["chain_id"] = spi
3858
3859             new_sfp = self.neutron.create_sfc_port_chain({"port_chain": sfp_dict})
3860
3861             return new_sfp["port_chain"]["id"]
3862         except (
3863             neExceptions.ConnectionFailed,
3864             ksExceptions.ClientException,
3865             neExceptions.NeutronException,
3866             ConnectionError,
3867         ) as e:
3868             if new_sfp:
3869                 try:
3870                     self.neutron.delete_sfc_port_chain(new_sfp["port_chain"]["id"])
3871                 except Exception:
3872                     self.logger.error(
3873                         "Creation of Service Function Path failed, with "
3874                         "subsequent deletion failure as well."
3875                     )
3876
3877             self._format_exception(e)
3878
3879     def get_sfp(self, sfp_id):
3880         self.logger.debug(" Getting Service Function Path %s from VIM", sfp_id)
3881
3882         filter_dict = {"id": sfp_id}
3883         sfp_list = self.get_sfp_list(filter_dict)
3884
3885         if len(sfp_list) == 0:
3886             raise vimconn.VimConnNotFoundException(
3887                 "Service Function Path '{}' not found".format(sfp_id)
3888             )
3889         elif len(sfp_list) > 1:
3890             raise vimconn.VimConnConflictException(
3891                 "Found more than one Service Function Path with this criteria"
3892             )
3893
3894         sfp = sfp_list[0]
3895
3896         return sfp
3897
3898     def get_sfp_list(self, filter_dict={}):
3899         self.logger.debug(
3900             "Getting Service Function Paths from VIM filter: '%s'", str(filter_dict)
3901         )
3902
3903         try:
3904             self._reload_connection()
3905             filter_dict_os = filter_dict.copy()
3906
3907             if self.api_version3 and "tenant_id" in filter_dict_os:
3908                 filter_dict_os["project_id"] = filter_dict_os.pop("tenant_id")
3909
3910             sfp_dict = self.neutron.list_sfc_port_chains(**filter_dict_os)
3911             sfp_list = sfp_dict["port_chains"]
3912             self.__sfp_os2mano(sfp_list)
3913
3914             return sfp_list
3915         except (
3916             neExceptions.ConnectionFailed,
3917             ksExceptions.ClientException,
3918             neExceptions.NeutronException,
3919             ConnectionError,
3920         ) as e:
3921             self._format_exception(e)
3922
3923     def delete_sfp(self, sfp_id):
3924         self.logger.debug("Deleting Service Function Path '%s' from VIM", sfp_id)
3925
3926         try:
3927             self._reload_connection()
3928             self.neutron.delete_sfc_port_chain(sfp_id)
3929
3930             return sfp_id
3931         except (
3932             neExceptions.ConnectionFailed,
3933             neExceptions.NeutronException,
3934             ksExceptions.ClientException,
3935             neExceptions.NeutronException,
3936             ConnectionError,
3937         ) as e:
3938             self._format_exception(e)
3939
3940     def refresh_sfps_status(self, sfp_list):
3941         """Get the status of the service function path
3942         Params: the list of sfp identifiers
3943         Returns a dictionary with:
3944             vm_id:          #VIM id of this service function path
3945                 status:     #Mandatory. Text with one of:
3946                             #  DELETED (not found at vim)
3947                             #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
3948                             #  OTHER (Vim reported other status not understood)
3949                             #  ERROR (VIM indicates an ERROR status)
3950                             #  ACTIVE,
3951                             #  CREATING (on building process)
3952                 error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
3953                 vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)F
3954         """
3955         sfp_dict = {}
3956         self.logger.debug(
3957             "refresh_sfps status: Getting tenant SFP information from VIM"
3958         )
3959
3960         for sfp_id in sfp_list:
3961             sfp = {}
3962
3963             try:
3964                 sfp_vim = self.get_sfp(sfp_id)
3965
3966                 if sfp_vim["spi"]:
3967                     sfp["status"] = vmStatus2manoFormat["ACTIVE"]
3968                 else:
3969                     sfp["status"] = "OTHER"
3970                     sfp["error_msg"] = "VIM status reported " + sfp["status"]
3971
3972                 sfp["vim_info"] = self.serialize(sfp_vim)
3973
3974                 if sfp_vim.get("fault"):
3975                     sfp["error_msg"] = str(sfp_vim["fault"])
3976             except vimconn.VimConnNotFoundException as e:
3977                 self.logger.error("Exception getting sfp status: %s", str(e))
3978                 sfp["status"] = "DELETED"
3979                 sfp["error_msg"] = str(e)
3980             except vimconn.VimConnException as e:
3981                 self.logger.error("Exception getting sfp status: %s", str(e))
3982                 sfp["status"] = "VIM_ERROR"
3983                 sfp["error_msg"] = str(e)
3984
3985             sfp_dict[sfp_id] = sfp
3986
3987         return sfp_dict
3988
3989     def refresh_sfis_status(self, sfi_list):
3990         """Get the status of the service function instances
3991         Params: the list of sfi identifiers
3992         Returns a dictionary with:
3993             vm_id:          #VIM id of this service function instance
3994                 status:     #Mandatory. Text with one of:
3995                             #  DELETED (not found at vim)
3996                             #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
3997                             #  OTHER (Vim reported other status not understood)
3998                             #  ERROR (VIM indicates an ERROR status)
3999                             #  ACTIVE,
4000                             #  CREATING (on building process)
4001                 error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
4002                 vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
4003         """
4004         sfi_dict = {}
4005         self.logger.debug(
4006             "refresh_sfis status: Getting tenant sfi information from VIM"
4007         )
4008
4009         for sfi_id in sfi_list:
4010             sfi = {}
4011
4012             try:
4013                 sfi_vim = self.get_sfi(sfi_id)
4014
4015                 if sfi_vim:
4016                     sfi["status"] = vmStatus2manoFormat["ACTIVE"]
4017                 else:
4018                     sfi["status"] = "OTHER"
4019                     sfi["error_msg"] = "VIM status reported " + sfi["status"]
4020
4021                 sfi["vim_info"] = self.serialize(sfi_vim)
4022
4023                 if sfi_vim.get("fault"):
4024                     sfi["error_msg"] = str(sfi_vim["fault"])
4025             except vimconn.VimConnNotFoundException as e:
4026                 self.logger.error("Exception getting sfi status: %s", str(e))
4027                 sfi["status"] = "DELETED"
4028                 sfi["error_msg"] = str(e)
4029             except vimconn.VimConnException as e:
4030                 self.logger.error("Exception getting sfi status: %s", str(e))
4031                 sfi["status"] = "VIM_ERROR"
4032                 sfi["error_msg"] = str(e)
4033
4034             sfi_dict[sfi_id] = sfi
4035
4036         return sfi_dict
4037
4038     def refresh_sfs_status(self, sf_list):
4039         """Get the status of the service functions
4040         Params: the list of sf identifiers
4041         Returns a dictionary with:
4042             vm_id:          #VIM id of this service function
4043                 status:     #Mandatory. Text with one of:
4044                             #  DELETED (not found at vim)
4045                             #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
4046                             #  OTHER (Vim reported other status not understood)
4047                             #  ERROR (VIM indicates an ERROR status)
4048                             #  ACTIVE,
4049                             #  CREATING (on building process)
4050                 error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
4051                 vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
4052         """
4053         sf_dict = {}
4054         self.logger.debug("refresh_sfs status: Getting tenant sf information from VIM")
4055
4056         for sf_id in sf_list:
4057             sf = {}
4058
4059             try:
4060                 sf_vim = self.get_sf(sf_id)
4061
4062                 if sf_vim:
4063                     sf["status"] = vmStatus2manoFormat["ACTIVE"]
4064                 else:
4065                     sf["status"] = "OTHER"
4066                     sf["error_msg"] = "VIM status reported " + sf_vim["status"]
4067
4068                 sf["vim_info"] = self.serialize(sf_vim)
4069
4070                 if sf_vim.get("fault"):
4071                     sf["error_msg"] = str(sf_vim["fault"])
4072             except vimconn.VimConnNotFoundException as e:
4073                 self.logger.error("Exception getting sf status: %s", str(e))
4074                 sf["status"] = "DELETED"
4075                 sf["error_msg"] = str(e)
4076             except vimconn.VimConnException as e:
4077                 self.logger.error("Exception getting sf status: %s", str(e))
4078                 sf["status"] = "VIM_ERROR"
4079                 sf["error_msg"] = str(e)
4080
4081             sf_dict[sf_id] = sf
4082
4083         return sf_dict
4084
4085     def refresh_classifications_status(self, classification_list):
4086         """Get the status of the classifications
4087         Params: the list of classification identifiers
4088         Returns a dictionary with:
4089             vm_id:          #VIM id of this classifier
4090                 status:     #Mandatory. Text with one of:
4091                             #  DELETED (not found at vim)
4092                             #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
4093                             #  OTHER (Vim reported other status not understood)
4094                             #  ERROR (VIM indicates an ERROR status)
4095                             #  ACTIVE,
4096                             #  CREATING (on building process)
4097                 error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
4098                 vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
4099         """
4100         classification_dict = {}
4101         self.logger.debug(
4102             "refresh_classifications status: Getting tenant classification information from VIM"
4103         )
4104
4105         for classification_id in classification_list:
4106             classification = {}
4107
4108             try:
4109                 classification_vim = self.get_classification(classification_id)
4110
4111                 if classification_vim:
4112                     classification["status"] = vmStatus2manoFormat["ACTIVE"]
4113                 else:
4114                     classification["status"] = "OTHER"
4115                     classification["error_msg"] = (
4116                         "VIM status reported " + classification["status"]
4117                     )
4118
4119                 classification["vim_info"] = self.serialize(classification_vim)
4120
4121                 if classification_vim.get("fault"):
4122                     classification["error_msg"] = str(classification_vim["fault"])
4123             except vimconn.VimConnNotFoundException as e:
4124                 self.logger.error("Exception getting classification status: %s", str(e))
4125                 classification["status"] = "DELETED"
4126                 classification["error_msg"] = str(e)
4127             except vimconn.VimConnException as e:
4128                 self.logger.error("Exception getting classification status: %s", str(e))
4129                 classification["status"] = "VIM_ERROR"
4130                 classification["error_msg"] = str(e)
4131
4132             classification_dict[classification_id] = classification
4133
4134         return classification_dict
4135
4136     def new_affinity_group(self, affinity_group_data):
4137         """Adds a server group to VIM
4138             affinity_group_data contains a dictionary with information, keys:
4139                 name: name in VIM for the server group
4140                 type: affinity or anti-affinity
4141                 scope: Only nfvi-node allowed
4142         Returns the server group identifier"""
4143         self.logger.debug("Adding Server Group '%s'", str(affinity_group_data))
4144
4145         try:
4146             name = affinity_group_data["name"]
4147             policy = affinity_group_data["type"]
4148
4149             self._reload_connection()
4150             new_server_group = self.nova.server_groups.create(name, policy)
4151
4152             return new_server_group.id
4153         except (
4154             ksExceptions.ClientException,
4155             nvExceptions.ClientException,
4156             ConnectionError,
4157             KeyError,
4158         ) as e:
4159             self._format_exception(e)
4160
4161     def get_affinity_group(self, affinity_group_id):
4162         """Obtain server group details from the VIM. Returns the server group detais as a dict"""
4163         self.logger.debug("Getting flavor '%s'", affinity_group_id)
4164         try:
4165             self._reload_connection()
4166             server_group = self.nova.server_groups.find(id=affinity_group_id)
4167
4168             return server_group.to_dict()
4169         except (
4170             nvExceptions.NotFound,
4171             nvExceptions.ClientException,
4172             ksExceptions.ClientException,
4173             ConnectionError,
4174         ) as e:
4175             self._format_exception(e)
4176
4177     def delete_affinity_group(self, affinity_group_id):
4178         """Deletes a server group from the VIM. Returns the old affinity_group_id"""
4179         self.logger.debug("Getting server group '%s'", affinity_group_id)
4180         try:
4181             self._reload_connection()
4182             self.nova.server_groups.delete(affinity_group_id)
4183
4184             return affinity_group_id
4185         except (
4186             nvExceptions.NotFound,
4187             ksExceptions.ClientException,
4188             nvExceptions.ClientException,
4189             ConnectionError,
4190         ) as e:
4191             self._format_exception(e)
4192
4193     def get_vdu_state(self, vm_id):
4194         """
4195         Getting the state of a vdu
4196         param:
4197             vm_id: ID of an instance
4198         """
4199         self.logger.debug("Getting the status of VM")
4200         self.logger.debug("VIM VM ID %s", vm_id)
4201         self._reload_connection()
4202         server = self.nova.servers.find(id=vm_id)
4203         server_dict = server.to_dict()
4204         vdu_data = [
4205             server_dict["status"],
4206             server_dict["flavor"]["id"],
4207             server_dict["OS-EXT-SRV-ATTR:host"],
4208             server_dict["OS-EXT-AZ:availability_zone"],
4209         ]
4210         self.logger.debug("vdu_data %s", vdu_data)
4211         return vdu_data
4212
4213     def check_compute_availability(self, host, server_flavor_details):
4214         self._reload_connection()
4215         hypervisor_search = self.nova.hypervisors.search(
4216             hypervisor_match=host, servers=True
4217         )
4218         for hypervisor in hypervisor_search:
4219             hypervisor_id = hypervisor.to_dict()["id"]
4220             hypervisor_details = self.nova.hypervisors.get(hypervisor=hypervisor_id)
4221             hypervisor_dict = hypervisor_details.to_dict()
4222             hypervisor_temp = json.dumps(hypervisor_dict)
4223             hypervisor_json = json.loads(hypervisor_temp)
4224             resources_available = [
4225                 hypervisor_json["free_ram_mb"],
4226                 hypervisor_json["disk_available_least"],
4227                 hypervisor_json["vcpus"] - hypervisor_json["vcpus_used"],
4228             ]
4229             compute_available = all(
4230                 x > y for x, y in zip(resources_available, server_flavor_details)
4231             )
4232             if compute_available:
4233                 return host
4234
4235     def check_availability_zone(
4236         self, old_az, server_flavor_details, old_host, host=None
4237     ):
4238         self._reload_connection()
4239         az_check = {"zone_check": False, "compute_availability": None}
4240         aggregates_list = self.nova.aggregates.list()
4241         for aggregate in aggregates_list:
4242             aggregate_details = aggregate.to_dict()
4243             aggregate_temp = json.dumps(aggregate_details)
4244             aggregate_json = json.loads(aggregate_temp)
4245             if aggregate_json["availability_zone"] == old_az:
4246                 hosts_list = aggregate_json["hosts"]
4247                 if host is not None:
4248                     if host in hosts_list:
4249                         az_check["zone_check"] = True
4250                         available_compute_id = self.check_compute_availability(
4251                             host, server_flavor_details
4252                         )
4253                         if available_compute_id is not None:
4254                             az_check["compute_availability"] = available_compute_id
4255                 else:
4256                     for check_host in hosts_list:
4257                         if check_host != old_host:
4258                             available_compute_id = self.check_compute_availability(
4259                                 check_host, server_flavor_details
4260                             )
4261                             if available_compute_id is not None:
4262                                 az_check["zone_check"] = True
4263                                 az_check["compute_availability"] = available_compute_id
4264                                 break
4265                     else:
4266                         az_check["zone_check"] = True
4267         return az_check
4268
4269     def migrate_instance(self, vm_id, compute_host=None):
4270         """
4271         Migrate a vdu
4272         param:
4273             vm_id: ID of an instance
4274             compute_host: Host to migrate the vdu to
4275         """
4276         self._reload_connection()
4277         vm_state = False
4278         instance_state = self.get_vdu_state(vm_id)
4279         server_flavor_id = instance_state[1]
4280         server_hypervisor_name = instance_state[2]
4281         server_availability_zone = instance_state[3]
4282         try:
4283             server_flavor = self.nova.flavors.find(id=server_flavor_id).to_dict()
4284             server_flavor_details = [
4285                 server_flavor["ram"],
4286                 server_flavor["disk"],
4287                 server_flavor["vcpus"],
4288             ]
4289             if compute_host == server_hypervisor_name:
4290                 raise vimconn.VimConnException(
4291                     "Unable to migrate instance '{}' to the same host '{}'".format(
4292                         vm_id, compute_host
4293                     ),
4294                     http_code=vimconn.HTTP_Bad_Request,
4295                 )
4296             az_status = self.check_availability_zone(
4297                 server_availability_zone,
4298                 server_flavor_details,
4299                 server_hypervisor_name,
4300                 compute_host,
4301             )
4302             availability_zone_check = az_status["zone_check"]
4303             available_compute_id = az_status.get("compute_availability")
4304
4305             if availability_zone_check is False:
4306                 raise vimconn.VimConnException(
4307                     "Unable to migrate instance '{}' to a different availability zone".format(
4308                         vm_id
4309                     ),
4310                     http_code=vimconn.HTTP_Bad_Request,
4311                 )
4312             if available_compute_id is not None:
4313                 self.nova.servers.live_migrate(
4314                     server=vm_id,
4315                     host=available_compute_id,
4316                     block_migration=True,
4317                     disk_over_commit=False,
4318                 )
4319                 state = "MIGRATING"
4320                 changed_compute_host = ""
4321                 if state == "MIGRATING":
4322                     vm_state = self.__wait_for_vm(vm_id, "ACTIVE")
4323                     changed_compute_host = self.get_vdu_state(vm_id)[2]
4324                 if vm_state and changed_compute_host == available_compute_id:
4325                     self.logger.debug(
4326                         "Instance '{}' migrated to the new compute host '{}'".format(
4327                             vm_id, changed_compute_host
4328                         )
4329                     )
4330                     return state, available_compute_id
4331                 else:
4332                     raise vimconn.VimConnException(
4333                         "Migration Failed. Instance '{}' not moved to the new host {}".format(
4334                             vm_id, available_compute_id
4335                         ),
4336                         http_code=vimconn.HTTP_Bad_Request,
4337                     )
4338             else:
4339                 raise vimconn.VimConnException(
4340                     "Compute '{}' not available or does not have enough resources to migrate the instance".format(
4341                         available_compute_id
4342                     ),
4343                     http_code=vimconn.HTTP_Bad_Request,
4344                 )
4345         except (
4346             nvExceptions.BadRequest,
4347             nvExceptions.ClientException,
4348             nvExceptions.NotFound,
4349         ) as e:
4350             self._format_exception(e)
4351
4352     def resize_instance(self, vm_id, new_flavor_id):
4353         """
4354         For resizing the vm based on the given
4355         flavor details
4356         param:
4357             vm_id : ID of an instance
4358             new_flavor_id : Flavor id to be resized
4359         Return the status of a resized instance
4360         """
4361         self._reload_connection()
4362         self.logger.debug("resize the flavor of an instance")
4363         instance_status, old_flavor_id, compute_host, az = self.get_vdu_state(vm_id)
4364         old_flavor_disk = self.nova.flavors.find(id=old_flavor_id).to_dict()["disk"]
4365         new_flavor_disk = self.nova.flavors.find(id=new_flavor_id).to_dict()["disk"]
4366         try:
4367             if instance_status == "ACTIVE" or instance_status == "SHUTOFF":
4368                 if old_flavor_disk > new_flavor_disk:
4369                     raise nvExceptions.BadRequest(
4370                         400,
4371                         message="Server disk resize failed. Resize to lower disk flavor is not allowed",
4372                     )
4373                 else:
4374                     self.nova.servers.resize(server=vm_id, flavor=new_flavor_id)
4375                     vm_state = self.__wait_for_vm(vm_id, "VERIFY_RESIZE")
4376                     if vm_state:
4377                         instance_resized_status = self.confirm_resize(vm_id)
4378                         return instance_resized_status
4379                     else:
4380                         raise nvExceptions.BadRequest(
4381                             409,
4382                             message="Cannot 'resize' vm_state is in ERROR",
4383                         )
4384
4385             else:
4386                 self.logger.debug("ERROR : Instance is not in ACTIVE or SHUTOFF state")
4387                 raise nvExceptions.BadRequest(
4388                     409,
4389                     message="Cannot 'resize' instance while it is in vm_state resized",
4390                 )
4391         except (
4392             nvExceptions.BadRequest,
4393             nvExceptions.ClientException,
4394             nvExceptions.NotFound,
4395         ) as e:
4396             self._format_exception(e)
4397
4398     def confirm_resize(self, vm_id):
4399         """
4400         Confirm the resize of an instance
4401         param:
4402             vm_id: ID of an instance
4403         """
4404         self._reload_connection()
4405         self.nova.servers.confirm_resize(server=vm_id)
4406         if self.get_vdu_state(vm_id)[0] == "VERIFY_RESIZE":
4407             self.__wait_for_vm(vm_id, "ACTIVE")
4408         instance_status = self.get_vdu_state(vm_id)[0]
4409         return instance_status