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