1 # -*- coding: utf-8 -*-
4 # Copyright 2015 Telefonica Investigacion y Desarrollo, S.A.U.
5 # This file is part of openmano
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
12 # http://www.apache.org/licenses/LICENSE-2.0
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
22 osconnector implements all the methods to interact with openstack using the python-neutronclient.
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)
34 from http
.client
import HTTPException
37 from pprint
import pformat
42 from cinderclient
import client
as cClient
43 from glanceclient
import client
as glClient
44 import glanceclient
.exc
as gl1Exceptions
45 from keystoneauth1
import session
46 from keystoneauth1
.identity
import v2
, v3
47 import keystoneclient
.exceptions
as ksExceptions
48 import keystoneclient
.v2_0
.client
as ksClient_v2
49 import keystoneclient
.v3
.client
as ksClient_v3
51 from neutronclient
.common
import exceptions
as neExceptions
52 from neutronclient
.neutron
import client
as neClient
53 from novaclient
import client
as nClient
, exceptions
as nvExceptions
54 from osm_ro_plugin
import vimconn
55 from requests
.exceptions
import ConnectionError
58 __author__
= "Alfonso Tierno, Gerardo Garcia, Pablo Montes, xFlow Research, Igor D.C., Eduardo Sousa"
59 __date__
= "$22-sep-2017 23:59:59$"
61 """contain the openstack virtual machine status to openmano status"""
62 vmStatus2manoFormat
= {
65 "SUSPENDED": "SUSPENDED",
66 "SHUTOFF": "INACTIVE",
71 netStatus2manoFormat
= {
74 "INACTIVE": "INACTIVE",
80 supportedClassificationTypes
= ["legacy_flow_classifier"]
82 # global var to have a timeout creating and deleting volumes
87 class SafeDumper(yaml
.SafeDumper
):
88 def represent_data(self
, data
):
89 # Openstack APIs use custom subclasses of dict and YAML safe dumper
90 # is designed to not handle that (reference issue 142 of pyyaml)
91 if isinstance(data
, dict) and data
.__class
__ != dict:
92 # A simple solution is to convert those items back to dicts
93 data
= dict(data
.items())
95 return super(SafeDumper
, self
).represent_data(data
)
98 class vimconnector(vimconn
.VimConnector
):
113 """using common constructor parameters. In this case
114 'url' is the keystone authorization url,
115 'url_admin' is not use
117 api_version
= config
.get("APIversion")
119 if api_version
and api_version
not in ("v3.3", "v2.0", "2", "3"):
120 raise vimconn
.VimConnException(
121 "Invalid value '{}' for config:APIversion. "
122 "Allowed values are 'v3.3', 'v2.0', '2' or '3'".format(api_version
)
125 vim_type
= config
.get("vim_type")
127 if vim_type
and vim_type
not in ("vio", "VIO"):
128 raise vimconn
.VimConnException(
129 "Invalid value '{}' for config:vim_type."
130 "Allowed values are 'vio' or 'VIO'".format(vim_type
)
133 if config
.get("dataplane_net_vlan_range") is not None:
134 # validate vlan ranges provided by user
135 self
._validate
_vlan
_ranges
(
136 config
.get("dataplane_net_vlan_range"), "dataplane_net_vlan_range"
139 if config
.get("multisegment_vlan_range") is not None:
140 # validate vlan ranges provided by user
141 self
._validate
_vlan
_ranges
(
142 config
.get("multisegment_vlan_range"), "multisegment_vlan_range"
145 vimconn
.VimConnector
.__init
__(
159 if self
.config
.get("insecure") and self
.config
.get("ca_cert"):
160 raise vimconn
.VimConnException(
161 "options insecure and ca_cert are mutually exclusive"
166 if self
.config
.get("insecure"):
169 if self
.config
.get("ca_cert"):
170 self
.verify
= self
.config
.get("ca_cert")
173 raise TypeError("url param can not be NoneType")
175 self
.persistent_info
= persistent_info
176 self
.availability_zone
= persistent_info
.get("availability_zone", None)
177 self
.session
= persistent_info
.get("session", {"reload_client": True})
178 self
.my_tenant_id
= self
.session
.get("my_tenant_id")
179 self
.nova
= self
.session
.get("nova")
180 self
.neutron
= self
.session
.get("neutron")
181 self
.cinder
= self
.session
.get("cinder")
182 self
.glance
= self
.session
.get("glance")
183 # self.glancev1 = self.session.get("glancev1")
184 self
.keystone
= self
.session
.get("keystone")
185 self
.api_version3
= self
.session
.get("api_version3")
186 self
.vim_type
= self
.config
.get("vim_type")
189 self
.vim_type
= self
.vim_type
.upper()
191 if self
.config
.get("use_internal_endpoint"):
192 self
.endpoint_type
= "internalURL"
194 self
.endpoint_type
= None
196 logging
.getLogger("urllib3").setLevel(logging
.WARNING
)
197 logging
.getLogger("keystoneauth").setLevel(logging
.WARNING
)
198 logging
.getLogger("novaclient").setLevel(logging
.WARNING
)
199 self
.logger
= logging
.getLogger("ro.vim.openstack")
201 # allow security_groups to be a list or a single string
202 if isinstance(self
.config
.get("security_groups"), str):
203 self
.config
["security_groups"] = [self
.config
["security_groups"]]
205 self
.security_groups_id
= None
207 # ###### VIO Specific Changes #########
208 if self
.vim_type
== "VIO":
209 self
.logger
= logging
.getLogger("ro.vim.vio")
212 self
.logger
.setLevel(getattr(logging
, log_level
))
214 def __getitem__(self
, index
):
215 """Get individuals parameters.
217 if index
== "project_domain_id":
218 return self
.config
.get("project_domain_id")
219 elif index
== "user_domain_id":
220 return self
.config
.get("user_domain_id")
222 return vimconn
.VimConnector
.__getitem
__(self
, index
)
224 def __setitem__(self
, index
, value
):
225 """Set individuals parameters and it is marked as dirty so to force connection reload.
227 if index
== "project_domain_id":
228 self
.config
["project_domain_id"] = value
229 elif index
== "user_domain_id":
230 self
.config
["user_domain_id"] = value
232 vimconn
.VimConnector
.__setitem
__(self
, index
, value
)
234 self
.session
["reload_client"] = True
236 def serialize(self
, value
):
237 """Serialization of python basic types.
239 In the case value is not serializable a message will be logged and a
240 simple representation of the data that cannot be converted back to
243 if isinstance(value
, str):
248 value
, Dumper
=SafeDumper
, default_flow_style
=True, width
=256
250 except yaml
.representer
.RepresenterError
:
252 "The following entity cannot be serialized in YAML:\n\n%s\n\n",
259 def _reload_connection(self
):
260 """Called before any operation, it check if credentials has changed
261 Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
263 # TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
264 if self
.session
["reload_client"]:
265 if self
.config
.get("APIversion"):
266 self
.api_version3
= (
267 self
.config
["APIversion"] == "v3.3"
268 or self
.config
["APIversion"] == "3"
270 else: # get from ending auth_url that end with v3 or with v2.0
271 self
.api_version3
= self
.url
.endswith("/v3") or self
.url
.endswith(
275 self
.session
["api_version3"] = self
.api_version3
277 if self
.api_version3
:
278 if self
.config
.get("project_domain_id") or self
.config
.get(
279 "project_domain_name"
281 project_domain_id_default
= None
283 project_domain_id_default
= "default"
285 if self
.config
.get("user_domain_id") or self
.config
.get(
288 user_domain_id_default
= None
290 user_domain_id_default
= "default"
294 password
=self
.passwd
,
295 project_name
=self
.tenant_name
,
296 project_id
=self
.tenant_id
,
297 project_domain_id
=self
.config
.get(
298 "project_domain_id", project_domain_id_default
300 user_domain_id
=self
.config
.get(
301 "user_domain_id", user_domain_id_default
303 project_domain_name
=self
.config
.get("project_domain_name"),
304 user_domain_name
=self
.config
.get("user_domain_name"),
310 password
=self
.passwd
,
311 tenant_name
=self
.tenant_name
,
312 tenant_id
=self
.tenant_id
,
315 sess
= session
.Session(auth
=auth
, verify
=self
.verify
)
316 # addedd region_name to keystone, nova, neutron and cinder to support distributed cloud for Wind River
317 # Titanium cloud and StarlingX
318 region_name
= self
.config
.get("region_name")
320 if self
.api_version3
:
321 self
.keystone
= ksClient_v3
.Client(
323 endpoint_type
=self
.endpoint_type
,
324 region_name
=region_name
,
327 self
.keystone
= ksClient_v2
.Client(
328 session
=sess
, endpoint_type
=self
.endpoint_type
331 self
.session
["keystone"] = self
.keystone
332 # In order to enable microversion functionality an explicit microversion must be specified in "config".
333 # This implementation approach is due to the warning message in
334 # https://developer.openstack.org/api-guide/compute/microversions.html
335 # where it is stated that microversion backwards compatibility is not guaranteed and clients should
336 # always require an specific microversion.
337 # To be able to use "device role tagging" functionality define "microversion: 2.32" in datacenter config
338 version
= self
.config
.get("microversion")
343 # addedd region_name to keystone, nova, neutron and cinder to support distributed cloud for Wind River
344 # Titanium cloud and StarlingX
345 self
.nova
= self
.session
["nova"] = nClient
.Client(
348 endpoint_type
=self
.endpoint_type
,
349 region_name
=region_name
,
351 self
.neutron
= self
.session
["neutron"] = neClient
.Client(
354 endpoint_type
=self
.endpoint_type
,
355 region_name
=region_name
,
357 self
.cinder
= self
.session
["cinder"] = cClient
.Client(
360 endpoint_type
=self
.endpoint_type
,
361 region_name
=region_name
,
365 self
.my_tenant_id
= self
.session
["my_tenant_id"] = sess
.get_project_id()
367 self
.logger
.error("Cannot get project_id from session", exc_info
=True)
369 if self
.endpoint_type
== "internalURL":
370 glance_service_id
= self
.keystone
.services
.list(name
="glance")[0].id
371 glance_endpoint
= self
.keystone
.endpoints
.list(
372 glance_service_id
, interface
="internal"
375 glance_endpoint
= None
377 self
.glance
= self
.session
["glance"] = glClient
.Client(
378 2, session
=sess
, endpoint
=glance_endpoint
380 # using version 1 of glance client in new_image()
381 # self.glancev1 = self.session["glancev1"] = glClient.Client("1", session=sess,
382 # endpoint=glance_endpoint)
383 self
.session
["reload_client"] = False
384 self
.persistent_info
["session"] = self
.session
385 # add availablity zone info inside self.persistent_info
386 self
._set
_availablity
_zones
()
387 self
.persistent_info
["availability_zone"] = self
.availability_zone
388 # force to get again security_groups_ids next time they are needed
389 self
.security_groups_id
= None
391 def __net_os2mano(self
, net_list_dict
):
392 """Transform the net openstack format to mano format
393 net_list_dict can be a list of dict or a single dict"""
394 if type(net_list_dict
) is dict:
395 net_list_
= (net_list_dict
,)
396 elif type(net_list_dict
) is list:
397 net_list_
= net_list_dict
399 raise TypeError("param net_list_dict must be a list or a dictionary")
400 for net
in net_list_
:
401 if net
.get("provider:network_type") == "vlan":
404 net
["type"] = "bridge"
406 def __classification_os2mano(self
, class_list_dict
):
407 """Transform the openstack format (Flow Classifier) to mano format
408 (Classification) class_list_dict can be a list of dict or a single dict
410 if isinstance(class_list_dict
, dict):
411 class_list_
= [class_list_dict
]
412 elif isinstance(class_list_dict
, list):
413 class_list_
= class_list_dict
415 raise TypeError("param class_list_dict must be a list or a dictionary")
416 for classification
in class_list_
:
417 id = classification
.pop("id")
418 name
= classification
.pop("name")
419 description
= classification
.pop("description")
420 project_id
= classification
.pop("project_id")
421 tenant_id
= classification
.pop("tenant_id")
422 original_classification
= copy
.deepcopy(classification
)
423 classification
.clear()
424 classification
["ctype"] = "legacy_flow_classifier"
425 classification
["definition"] = original_classification
426 classification
["id"] = id
427 classification
["name"] = name
428 classification
["description"] = description
429 classification
["project_id"] = project_id
430 classification
["tenant_id"] = tenant_id
432 def __sfi_os2mano(self
, sfi_list_dict
):
433 """Transform the openstack format (Port Pair) to mano format (SFI)
434 sfi_list_dict can be a list of dict or a single dict
436 if isinstance(sfi_list_dict
, dict):
437 sfi_list_
= [sfi_list_dict
]
438 elif isinstance(sfi_list_dict
, list):
439 sfi_list_
= sfi_list_dict
441 raise TypeError("param sfi_list_dict must be a list or a dictionary")
443 for sfi
in sfi_list_
:
444 sfi
["ingress_ports"] = []
445 sfi
["egress_ports"] = []
447 if sfi
.get("ingress"):
448 sfi
["ingress_ports"].append(sfi
["ingress"])
450 if sfi
.get("egress"):
451 sfi
["egress_ports"].append(sfi
["egress"])
455 params
= sfi
.get("service_function_parameters")
459 correlation
= params
.get("correlation")
464 sfi
["sfc_encap"] = sfc_encap
465 del sfi
["service_function_parameters"]
467 def __sf_os2mano(self
, sf_list_dict
):
468 """Transform the openstack format (Port Pair Group) to mano format (SF)
469 sf_list_dict can be a list of dict or a single dict
471 if isinstance(sf_list_dict
, dict):
472 sf_list_
= [sf_list_dict
]
473 elif isinstance(sf_list_dict
, list):
474 sf_list_
= sf_list_dict
476 raise TypeError("param sf_list_dict must be a list or a dictionary")
479 del sf
["port_pair_group_parameters"]
480 sf
["sfis"] = sf
["port_pairs"]
483 def __sfp_os2mano(self
, sfp_list_dict
):
484 """Transform the openstack format (Port Chain) to mano format (SFP)
485 sfp_list_dict can be a list of dict or a single dict
487 if isinstance(sfp_list_dict
, dict):
488 sfp_list_
= [sfp_list_dict
]
489 elif isinstance(sfp_list_dict
, list):
490 sfp_list_
= sfp_list_dict
492 raise TypeError("param sfp_list_dict must be a list or a dictionary")
494 for sfp
in sfp_list_
:
495 params
= sfp
.pop("chain_parameters")
499 correlation
= params
.get("correlation")
504 sfp
["sfc_encap"] = sfc_encap
505 sfp
["spi"] = sfp
.pop("chain_id")
506 sfp
["classifications"] = sfp
.pop("flow_classifiers")
507 sfp
["service_functions"] = sfp
.pop("port_pair_groups")
509 # placeholder for now; read TODO note below
510 def _validate_classification(self
, type, definition
):
511 # only legacy_flow_classifier Type is supported at this point
513 # TODO(igordcard): this method should be an abstract method of an
514 # abstract Classification class to be implemented by the specific
515 # Types. Also, abstract vimconnector should call the validation
516 # method before the implemented VIM connectors are called.
518 def _format_exception(self
, exception
):
519 """Transform a keystone, nova, neutron exception into a vimconn exception discovering the cause"""
520 message_error
= str(exception
)
526 neExceptions
.NetworkNotFoundClient
,
527 nvExceptions
.NotFound
,
528 ksExceptions
.NotFound
,
529 gl1Exceptions
.HTTPNotFound
,
532 raise vimconn
.VimConnNotFoundException(
533 type(exception
).__name
__ + ": " + message_error
539 gl1Exceptions
.HTTPException
,
540 gl1Exceptions
.CommunicationError
,
542 ksExceptions
.ConnectionError
,
543 neExceptions
.ConnectionFailed
,
546 if type(exception
).__name
__ == "SSLError":
547 tip
= " (maybe option 'insecure' must be added to the VIM)"
549 raise vimconn
.VimConnConnectionException(
550 "Invalid URL or credentials{}: {}".format(tip
, message_error
)
556 nvExceptions
.BadRequest
,
557 ksExceptions
.BadRequest
,
560 raise vimconn
.VimConnException(
561 type(exception
).__name
__ + ": " + message_error
566 nvExceptions
.ClientException
,
567 ksExceptions
.ClientException
,
568 neExceptions
.NeutronException
,
571 raise vimconn
.VimConnUnexpectedResponse(
572 type(exception
).__name
__ + ": " + message_error
574 elif isinstance(exception
, nvExceptions
.Conflict
):
575 raise vimconn
.VimConnConflictException(
576 type(exception
).__name
__ + ": " + message_error
578 elif isinstance(exception
, vimconn
.VimConnException
):
581 self
.logger
.error("General Exception " + message_error
, exc_info
=True)
583 raise vimconn
.VimConnConnectionException(
584 type(exception
).__name
__ + ": " + message_error
587 def _get_ids_from_name(self
):
589 Obtain ids from name of tenant and security_groups. Store at self .security_groups_id"
592 # get tenant_id if only tenant_name is supplied
593 self
._reload
_connection
()
595 if not self
.my_tenant_id
:
596 raise vimconn
.VimConnConnectionException(
597 "Error getting tenant information from name={} id={}".format(
598 self
.tenant_name
, self
.tenant_id
602 if self
.config
.get("security_groups") and not self
.security_groups_id
:
603 # convert from name to id
604 neutron_sg_list
= self
.neutron
.list_security_groups(
605 tenant_id
=self
.my_tenant_id
608 self
.security_groups_id
= []
609 for sg
in self
.config
.get("security_groups"):
610 for neutron_sg
in neutron_sg_list
:
611 if sg
in (neutron_sg
["id"], neutron_sg
["name"]):
612 self
.security_groups_id
.append(neutron_sg
["id"])
615 self
.security_groups_id
= None
617 raise vimconn
.VimConnConnectionException(
618 "Not found security group {} for this tenant".format(sg
)
621 def check_vim_connectivity(self
):
622 # just get network list to check connectivity and credentials
623 self
.get_network_list(filter_dict
={})
625 def get_tenant_list(self
, filter_dict
={}):
626 """Obtain tenants of VIM
627 filter_dict can contain the following keys:
628 name: filter by tenant name
629 id: filter by tenant uuid/id
631 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
633 self
.logger
.debug("Getting tenants from VIM filter: '%s'", str(filter_dict
))
636 self
._reload
_connection
()
638 if self
.api_version3
:
639 project_class_list
= self
.keystone
.projects
.list(
640 name
=filter_dict
.get("name")
643 project_class_list
= self
.keystone
.tenants
.findall(**filter_dict
)
647 for project
in project_class_list
:
648 if filter_dict
.get("id") and filter_dict
["id"] != project
.id:
651 project_list
.append(project
.to_dict())
655 ksExceptions
.ConnectionError
,
656 ksExceptions
.ClientException
,
659 self
._format
_exception
(e
)
661 def new_tenant(self
, tenant_name
, tenant_description
):
662 """Adds a new tenant to openstack VIM. Returns the tenant identifier"""
663 self
.logger
.debug("Adding a new tenant name: %s", tenant_name
)
666 self
._reload
_connection
()
668 if self
.api_version3
:
669 project
= self
.keystone
.projects
.create(
671 self
.config
.get("project_domain_id", "default"),
672 description
=tenant_description
,
676 project
= self
.keystone
.tenants
.create(tenant_name
, tenant_description
)
680 ksExceptions
.ConnectionError
,
681 ksExceptions
.ClientException
,
682 ksExceptions
.BadRequest
,
685 self
._format
_exception
(e
)
687 def delete_tenant(self
, tenant_id
):
688 """Delete a tenant from openstack VIM. Returns the old tenant identifier"""
689 self
.logger
.debug("Deleting tenant %s from VIM", tenant_id
)
692 self
._reload
_connection
()
694 if self
.api_version3
:
695 self
.keystone
.projects
.delete(tenant_id
)
697 self
.keystone
.tenants
.delete(tenant_id
)
701 ksExceptions
.ConnectionError
,
702 ksExceptions
.ClientException
,
703 ksExceptions
.NotFound
,
706 self
._format
_exception
(e
)
714 provider_network_profile
=None,
716 """Adds a tenant network to VIM
718 'net_name': name of the network
720 'bridge': overlay isolated network
721 'data': underlay E-LAN network for Passthrough and SRIOV interfaces
722 'ptp': underlay E-LINE network for Passthrough and SRIOV interfaces.
723 'ip_profile': is a dict containing the IP parameters of the network
724 'ip_version': can be "IPv4" or "IPv6" (Currently only IPv4 is implemented)
725 'subnet_address': ip_prefix_schema, that is X.X.X.X/Y
726 'gateway_address': (Optional) ip_schema, that is X.X.X.X
727 'dns_address': (Optional) comma separated list of ip_schema, e.g. X.X.X.X[,X,X,X,X]
728 'dhcp_enabled': True or False
729 'dhcp_start_address': ip_schema, first IP to grant
730 'dhcp_count': number of IPs to grant.
731 'shared': if this network can be seen/use by other tenants/organization
732 'provider_network_profile': (optional) contains {segmentation-id: vlan, network-type: vlan|vxlan,
733 physical-network: physnet-label}
734 Returns a tuple with the network identifier and created_items, or raises an exception on error
735 created_items can be None or a dictionary where this method can include key-values that will be passed to
736 the method delete_network. Can be used to store created segments, created l2gw connections, etc.
737 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
741 "Adding a new network to VIM name '%s', type '%s'", net_name
, net_type
743 # self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
748 if provider_network_profile
:
749 vlan
= provider_network_profile
.get("segmentation-id")
753 self
._reload
_connection
()
754 network_dict
= {"name": net_name
, "admin_state_up": True}
756 if net_type
in ("data", "ptp"):
757 provider_physical_network
= None
759 if provider_network_profile
and provider_network_profile
.get(
762 provider_physical_network
= provider_network_profile
.get(
766 # provider-network must be one of the dataplane_physcial_netowrk if this is a list. If it is string
767 # or not declared, just ignore the checking
770 self
.config
.get("dataplane_physical_net"), (tuple, list)
772 and provider_physical_network
773 not in self
.config
["dataplane_physical_net"]
775 raise vimconn
.VimConnConflictException(
776 "Invalid parameter 'provider-network:physical-network' "
777 "for network creation. '{}' is not one of the declared "
778 "list at VIM_config:dataplane_physical_net".format(
779 provider_physical_network
783 # use the default dataplane_physical_net
784 if not provider_physical_network
:
785 provider_physical_network
= self
.config
.get(
786 "dataplane_physical_net"
789 # if it is non empty list, use the first value. If it is a string use the value directly
791 isinstance(provider_physical_network
, (tuple, list))
792 and provider_physical_network
794 provider_physical_network
= provider_physical_network
[0]
796 if not provider_physical_network
:
797 raise vimconn
.VimConnConflictException(
798 "missing information needed for underlay networks. Provide "
799 "'dataplane_physical_net' configuration at VIM or use the NS "
800 "instantiation parameter 'provider-network.physical-network'"
804 if not self
.config
.get("multisegment_support"):
806 "provider:physical_network"
807 ] = provider_physical_network
810 provider_network_profile
811 and "network-type" in provider_network_profile
814 "provider:network_type"
815 ] = provider_network_profile
["network-type"]
817 network_dict
["provider:network_type"] = self
.config
.get(
818 "dataplane_network_type", "vlan"
822 network_dict
["provider:segmentation_id"] = vlan
827 "provider:physical_network": "",
828 "provider:network_type": "vxlan",
830 segment_list
.append(segment1_dict
)
832 "provider:physical_network": provider_physical_network
,
833 "provider:network_type": "vlan",
837 segment2_dict
["provider:segmentation_id"] = vlan
838 elif self
.config
.get("multisegment_vlan_range"):
839 vlanID
= self
._generate
_multisegment
_vlanID
()
840 segment2_dict
["provider:segmentation_id"] = vlanID
843 # raise vimconn.VimConnConflictException(
844 # "You must provide "multisegment_vlan_range" at config dict before creating a multisegment
846 segment_list
.append(segment2_dict
)
847 network_dict
["segments"] = segment_list
849 # VIO Specific Changes. It needs a concrete VLAN
850 if self
.vim_type
== "VIO" and vlan
is None:
851 if self
.config
.get("dataplane_net_vlan_range") is None:
852 raise vimconn
.VimConnConflictException(
853 "You must provide 'dataplane_net_vlan_range' in format "
854 "[start_ID - end_ID] at VIM_config for creating underlay "
858 network_dict
["provider:segmentation_id"] = self
._generate
_vlanID
()
860 network_dict
["shared"] = shared
862 if self
.config
.get("disable_network_port_security"):
863 network_dict
["port_security_enabled"] = False
865 if self
.config
.get("neutron_availability_zone_hints"):
866 hints
= self
.config
.get("neutron_availability_zone_hints")
868 if isinstance(hints
, str):
871 network_dict
["availability_zone_hints"] = hints
873 new_net
= self
.neutron
.create_network({"network": network_dict
})
875 # create subnetwork, even if there is no profile
880 if not ip_profile
.get("subnet_address"):
881 # Fake subnet is required
882 subnet_rand
= random
.randint(0, 255)
883 ip_profile
["subnet_address"] = "192.168.{}.0/24".format(subnet_rand
)
885 if "ip_version" not in ip_profile
:
886 ip_profile
["ip_version"] = "IPv4"
889 "name": net_name
+ "-subnet",
890 "network_id": new_net
["network"]["id"],
891 "ip_version": 4 if ip_profile
["ip_version"] == "IPv4" else 6,
892 "cidr": ip_profile
["subnet_address"],
895 # Gateway should be set to None if not needed. Otherwise openstack assigns one by default
896 if ip_profile
.get("gateway_address"):
897 subnet
["gateway_ip"] = ip_profile
["gateway_address"]
899 subnet
["gateway_ip"] = None
901 if ip_profile
.get("dns_address"):
902 subnet
["dns_nameservers"] = ip_profile
["dns_address"].split(";")
904 if "dhcp_enabled" in ip_profile
:
905 subnet
["enable_dhcp"] = (
907 if ip_profile
["dhcp_enabled"] == "false"
908 or ip_profile
["dhcp_enabled"] is False
912 if ip_profile
.get("dhcp_start_address"):
913 subnet
["allocation_pools"] = []
914 subnet
["allocation_pools"].append(dict())
915 subnet
["allocation_pools"][0]["start"] = ip_profile
[
919 if ip_profile
.get("dhcp_count"):
920 # parts = ip_profile["dhcp_start_address"].split(".")
921 # ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
922 ip_int
= int(netaddr
.IPAddress(ip_profile
["dhcp_start_address"]))
923 ip_int
+= ip_profile
["dhcp_count"] - 1
924 ip_str
= str(netaddr
.IPAddress(ip_int
))
925 subnet
["allocation_pools"][0]["end"] = ip_str
927 # self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
928 self
.neutron
.create_subnet({"subnet": subnet
})
930 if net_type
== "data" and self
.config
.get("multisegment_support"):
931 if self
.config
.get("l2gw_support"):
932 l2gw_list
= self
.neutron
.list_l2_gateways().get("l2_gateways", ())
933 for l2gw
in l2gw_list
:
935 "l2_gateway_id": l2gw
["id"],
936 "network_id": new_net
["network"]["id"],
937 "segmentation_id": str(vlanID
),
939 new_l2gw_conn
= self
.neutron
.create_l2_gateway_connection(
940 {"l2_gateway_connection": l2gw_conn
}
944 + str(new_l2gw_conn
["l2_gateway_connection"]["id"])
947 return new_net
["network"]["id"], created_items
948 except Exception as e
:
949 # delete l2gw connections (if any) before deleting the network
950 for k
, v
in created_items
.items():
951 if not v
: # skip already deleted
955 k_item
, _
, k_id
= k
.partition(":")
957 if k_item
== "l2gwconn":
958 self
.neutron
.delete_l2_gateway_connection(k_id
)
959 except Exception as e2
:
961 "Error deleting l2 gateway connection: {}: {}".format(
962 type(e2
).__name
__, e2
967 self
.neutron
.delete_network(new_net
["network"]["id"])
969 self
._format
_exception
(e
)
971 def get_network_list(self
, filter_dict
={}):
972 """Obtain tenant networks of VIM
978 admin_state_up: boolean
980 Returns the network list of dictionaries
982 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
985 self
._reload
_connection
()
986 filter_dict_os
= filter_dict
.copy()
988 if self
.api_version3
and "tenant_id" in filter_dict_os
:
990 filter_dict_os
["project_id"] = filter_dict_os
.pop("tenant_id")
992 net_dict
= self
.neutron
.list_networks(**filter_dict_os
)
993 net_list
= net_dict
["networks"]
994 self
.__net
_os
2mano
(net_list
)
998 neExceptions
.ConnectionFailed
,
999 ksExceptions
.ClientException
,
1000 neExceptions
.NeutronException
,
1003 self
._format
_exception
(e
)
1005 def get_network(self
, net_id
):
1006 """Obtain details of network from VIM
1007 Returns the network information from a network id"""
1008 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
1009 filter_dict
= {"id": net_id
}
1010 net_list
= self
.get_network_list(filter_dict
)
1012 if len(net_list
) == 0:
1013 raise vimconn
.VimConnNotFoundException(
1014 "Network '{}' not found".format(net_id
)
1016 elif len(net_list
) > 1:
1017 raise vimconn
.VimConnConflictException(
1018 "Found more than one network with this criteria"
1023 for subnet_id
in net
.get("subnets", ()):
1025 subnet
= self
.neutron
.show_subnet(subnet_id
)
1026 except Exception as e
:
1028 "osconnector.get_network(): Error getting subnet %s %s"
1031 subnet
= {"id": subnet_id
, "fault": str(e
)}
1033 subnets
.append(subnet
)
1035 net
["subnets"] = subnets
1036 net
["encapsulation"] = net
.get("provider:network_type")
1037 net
["encapsulation_type"] = net
.get("provider:network_type")
1038 net
["segmentation_id"] = net
.get("provider:segmentation_id")
1039 net
["encapsulation_id"] = net
.get("provider:segmentation_id")
1043 def delete_network(self
, net_id
, created_items
=None):
1045 Removes a tenant network from VIM and its associated elements
1046 :param net_id: VIM identifier of the network, provided by method new_network
1047 :param created_items: dictionary with extra items to be deleted. provided by method new_network
1048 Returns the network identifier or raises an exception upon error or when network is not found
1050 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
1052 if created_items
is None:
1056 self
._reload
_connection
()
1057 # delete l2gw connections (if any) before deleting the network
1058 for k
, v
in created_items
.items():
1059 if not v
: # skip already deleted
1063 k_item
, _
, k_id
= k
.partition(":")
1064 if k_item
== "l2gwconn":
1065 self
.neutron
.delete_l2_gateway_connection(k_id
)
1066 except Exception as e
:
1068 "Error deleting l2 gateway connection: {}: {}".format(
1073 # delete VM ports attached to this networks before the network
1074 ports
= self
.neutron
.list_ports(network_id
=net_id
)
1075 for p
in ports
["ports"]:
1077 self
.neutron
.delete_port(p
["id"])
1078 except Exception as e
:
1079 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
1081 self
.neutron
.delete_network(net_id
)
1085 neExceptions
.ConnectionFailed
,
1086 neExceptions
.NetworkNotFoundClient
,
1087 neExceptions
.NeutronException
,
1088 ksExceptions
.ClientException
,
1089 neExceptions
.NeutronException
,
1092 self
._format
_exception
(e
)
1094 def refresh_nets_status(self
, net_list
):
1095 """Get the status of the networks
1096 Params: the list of network identifiers
1097 Returns a dictionary with:
1098 net_id: #VIM id of this network
1099 status: #Mandatory. Text with one of:
1100 # DELETED (not found at vim)
1101 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1102 # OTHER (Vim reported other status not understood)
1103 # ERROR (VIM indicates an ERROR status)
1104 # ACTIVE, INACTIVE, DOWN (admin down),
1105 # BUILD (on building process)
1107 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1108 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1112 for net_id
in net_list
:
1116 net_vim
= self
.get_network(net_id
)
1118 if net_vim
["status"] in netStatus2manoFormat
:
1119 net
["status"] = netStatus2manoFormat
[net_vim
["status"]]
1121 net
["status"] = "OTHER"
1122 net
["error_msg"] = "VIM status reported " + net_vim
["status"]
1124 if net
["status"] == "ACTIVE" and not net_vim
["admin_state_up"]:
1125 net
["status"] = "DOWN"
1127 net
["vim_info"] = self
.serialize(net_vim
)
1129 if net_vim
.get("fault"): # TODO
1130 net
["error_msg"] = str(net_vim
["fault"])
1131 except vimconn
.VimConnNotFoundException
as e
:
1132 self
.logger
.error("Exception getting net status: %s", str(e
))
1133 net
["status"] = "DELETED"
1134 net
["error_msg"] = str(e
)
1135 except vimconn
.VimConnException
as e
:
1136 self
.logger
.error("Exception getting net status: %s", str(e
))
1137 net
["status"] = "VIM_ERROR"
1138 net
["error_msg"] = str(e
)
1139 net_dict
[net_id
] = net
1142 def get_flavor(self
, flavor_id
):
1143 """Obtain flavor details from the VIM. Returns the flavor dict details"""
1144 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
1147 self
._reload
_connection
()
1148 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
1149 # TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
1151 return flavor
.to_dict()
1153 nvExceptions
.NotFound
,
1154 nvExceptions
.ClientException
,
1155 ksExceptions
.ClientException
,
1158 self
._format
_exception
(e
)
1160 def get_flavor_id_from_data(self
, flavor_dict
):
1161 """Obtain flavor id that match the flavor description
1162 Returns the flavor_id or raises a vimconnNotFoundException
1163 flavor_dict: contains the required ram, vcpus, disk
1164 If 'use_existing_flavors' is set to True at config, the closer flavor that provides same or more ram, vcpus
1165 and disk is returned. Otherwise a flavor with exactly same ram, vcpus and disk is returned or a
1166 vimconnNotFoundException is raised
1168 exact_match
= False if self
.config
.get("use_existing_flavors") else True
1171 self
._reload
_connection
()
1172 flavor_candidate_id
= None
1173 flavor_candidate_data
= (10000, 10000, 10000)
1176 flavor_dict
["vcpus"],
1177 flavor_dict
["disk"],
1178 flavor_dict
.get("ephemeral", 0),
1179 flavor_dict
.get("swap", 0),
1182 extended
= flavor_dict
.get("extended", {})
1185 raise vimconn
.VimConnNotFoundException(
1186 "Flavor with EPA still not implemented"
1188 # if len(numas) > 1:
1189 # raise vimconn.VimConnNotFoundException("Cannot find any flavor with more than one numa")
1191 # numas = extended.get("numas")
1192 for flavor
in self
.nova
.flavors
.list():
1193 epa
= flavor
.get_keys()
1204 flavor
.swap
if isinstance(flavor
.swap
, int) else 0,
1206 if flavor_data
== flavor_target
:
1210 and flavor_target
< flavor_data
< flavor_candidate_data
1212 flavor_candidate_id
= flavor
.id
1213 flavor_candidate_data
= flavor_data
1215 if not exact_match
and flavor_candidate_id
:
1216 return flavor_candidate_id
1218 raise vimconn
.VimConnNotFoundException(
1219 "Cannot find any flavor matching '{}'".format(flavor_dict
)
1222 nvExceptions
.NotFound
,
1223 nvExceptions
.ClientException
,
1224 ksExceptions
.ClientException
,
1227 self
._format
_exception
(e
)
1229 def process_resource_quota(self
, quota
, prefix
, extra_specs
):
1235 if "limit" in quota
:
1236 extra_specs
["quota:" + prefix
+ "_limit"] = quota
["limit"]
1238 if "reserve" in quota
:
1239 extra_specs
["quota:" + prefix
+ "_reservation"] = quota
["reserve"]
1241 if "shares" in quota
:
1242 extra_specs
["quota:" + prefix
+ "_shares_level"] = "custom"
1243 extra_specs
["quota:" + prefix
+ "_shares_share"] = quota
["shares"]
1245 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
1246 """Adds a tenant flavor to openstack VIM
1247 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name
1249 Returns the flavor identifier
1251 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
1257 name
= flavor_data
["name"]
1258 while retry
< max_retries
:
1261 self
._reload
_connection
()
1263 if change_name_if_used
:
1266 fl
= self
.nova
.flavors
.list()
1269 fl_names
.append(f
.name
)
1271 while name
in fl_names
:
1273 name
= flavor_data
["name"] + "-" + str(name_suffix
)
1275 ram
= flavor_data
.get("ram", 64)
1276 vcpus
= flavor_data
.get("vcpus", 1)
1279 extended
= flavor_data
.get("extended")
1281 numas
= extended
.get("numas")
1284 numa_nodes
= len(numas
)
1287 return -1, "Can not add flavor with more than one numa"
1289 extra_specs
["hw:numa_nodes"] = str(numa_nodes
)
1290 extra_specs
["hw:mem_page_size"] = "large"
1291 extra_specs
["hw:cpu_policy"] = "dedicated"
1292 extra_specs
["hw:numa_mempolicy"] = "strict"
1294 if self
.vim_type
== "VIO":
1296 "vmware:extra_config"
1297 ] = '{"numa.nodeAffinity":"0"}'
1298 extra_specs
["vmware:latency_sensitivity_level"] = "high"
1301 # overwrite ram and vcpus
1302 # check if key "memory" is present in numa else use ram value at flavor
1303 if "memory" in numa
:
1304 ram
= numa
["memory"] * 1024
1305 # See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/
1306 # implemented/virt-driver-cpu-thread-pinning.html
1307 extra_specs
["hw:cpu_sockets"] = 1
1309 if "paired-threads" in numa
:
1310 vcpus
= numa
["paired-threads"] * 2
1311 # cpu_thread_policy "require" implies that the compute node must have an
1313 extra_specs
["hw:cpu_thread_policy"] = "require"
1314 extra_specs
["hw:cpu_policy"] = "dedicated"
1315 elif "cores" in numa
:
1316 vcpus
= numa
["cores"]
1317 # cpu_thread_policy "prefer" implies that the host must not have an SMT
1318 # architecture, or a non-SMT architecture will be emulated
1319 extra_specs
["hw:cpu_thread_policy"] = "isolate"
1320 extra_specs
["hw:cpu_policy"] = "dedicated"
1321 elif "threads" in numa
:
1322 vcpus
= numa
["threads"]
1323 # cpu_thread_policy "prefer" implies that the host may or may not have an SMT
1325 extra_specs
["hw:cpu_thread_policy"] = "prefer"
1326 extra_specs
["hw:cpu_policy"] = "dedicated"
1327 # for interface in numa.get("interfaces",() ):
1328 # if interface["dedicated"]=="yes":
1329 # raise vimconn.VimConnException("Passthrough interfaces are not supported
1330 # for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
1331 # #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"'
1332 # when a way to connect it is available
1333 elif extended
.get("cpu-quota"):
1334 self
.process_resource_quota(
1335 extended
.get("cpu-quota"), "cpu", extra_specs
1338 if extended
.get("mem-quota"):
1339 self
.process_resource_quota(
1340 extended
.get("mem-quota"), "memory", extra_specs
1343 if extended
.get("vif-quota"):
1344 self
.process_resource_quota(
1345 extended
.get("vif-quota"), "vif", extra_specs
1348 if extended
.get("disk-io-quota"):
1349 self
.process_resource_quota(
1350 extended
.get("disk-io-quota"), "disk_io", extra_specs
1353 # Set the mempage size as specified in the descriptor
1354 if extended
.get("mempage-size"):
1355 if extended
.get("mempage-size") == "LARGE":
1356 extra_specs
["hw:mem_page_size"] = "large"
1357 elif extended
.get("mempage-size") == "SMALL":
1358 extra_specs
["hw:mem_page_size"] = "small"
1359 elif extended
.get("mempage-size") == "SIZE_2MB":
1360 extra_specs
["hw:mem_page_size"] = "2MB"
1361 elif extended
.get("mempage-size") == "SIZE_1GB":
1362 extra_specs
["hw:mem_page_size"] = "1GB"
1363 elif extended
.get("mempage-size") == "PREFER_LARGE":
1364 extra_specs
["hw:mem_page_size"] = "any"
1366 # The validations in NBI should make reaching here not possible.
1367 # If this message is shown, check validations
1369 "Invalid mempage-size %s. Will be ignored",
1370 extended
.get("mempage-size"),
1373 new_flavor
= self
.nova
.flavors
.create(
1377 disk
=flavor_data
.get("disk", 0),
1378 ephemeral
=flavor_data
.get("ephemeral", 0),
1379 swap
=flavor_data
.get("swap", 0),
1380 is_public
=flavor_data
.get("is_public", True),
1384 new_flavor
.set_keys(extra_specs
)
1386 return new_flavor
.id
1387 except nvExceptions
.Conflict
as e
:
1388 if change_name_if_used
and retry
< max_retries
:
1391 self
._format
_exception
(e
)
1392 # except nvExceptions.BadRequest as e:
1394 ksExceptions
.ClientException
,
1395 nvExceptions
.ClientException
,
1399 self
._format
_exception
(e
)
1401 def delete_flavor(self
, flavor_id
):
1402 """Deletes a tenant flavor from openstack VIM. Returns the old flavor_id"""
1404 self
._reload
_connection
()
1405 self
.nova
.flavors
.delete(flavor_id
)
1408 # except nvExceptions.BadRequest as e:
1410 nvExceptions
.NotFound
,
1411 ksExceptions
.ClientException
,
1412 nvExceptions
.ClientException
,
1415 self
._format
_exception
(e
)
1417 def new_image(self
, image_dict
):
1419 Adds a tenant image to VIM. imge_dict is a dictionary with:
1421 disk_format: qcow2, vhd, vmdk, raw (by default), ...
1422 location: path or URI
1423 public: "yes" or "no"
1424 metadata: metadata of the image
1425 Returns the image_id
1430 while retry
< max_retries
:
1433 self
._reload
_connection
()
1435 # determine format http://docs.openstack.org/developer/glance/formats.html
1436 if "disk_format" in image_dict
:
1437 disk_format
= image_dict
["disk_format"]
1438 else: # autodiscover based on extension
1439 if image_dict
["location"].endswith(".qcow2"):
1440 disk_format
= "qcow2"
1441 elif image_dict
["location"].endswith(".vhd"):
1443 elif image_dict
["location"].endswith(".vmdk"):
1444 disk_format
= "vmdk"
1445 elif image_dict
["location"].endswith(".vdi"):
1447 elif image_dict
["location"].endswith(".iso"):
1449 elif image_dict
["location"].endswith(".aki"):
1451 elif image_dict
["location"].endswith(".ari"):
1453 elif image_dict
["location"].endswith(".ami"):
1459 "new_image: '%s' loading from '%s'",
1461 image_dict
["location"],
1463 if self
.vim_type
== "VIO":
1464 container_format
= "bare"
1465 if "container_format" in image_dict
:
1466 container_format
= image_dict
["container_format"]
1468 new_image
= self
.glance
.images
.create(
1469 name
=image_dict
["name"],
1470 container_format
=container_format
,
1471 disk_format
=disk_format
,
1474 new_image
= self
.glance
.images
.create(name
=image_dict
["name"])
1476 if image_dict
["location"].startswith("http"):
1477 # TODO there is not a method to direct download. It must be downloaded locally with requests
1478 raise vimconn
.VimConnNotImplemented("Cannot create image from URL")
1480 with
open(image_dict
["location"]) as fimage
:
1481 self
.glance
.images
.upload(new_image
.id, fimage
)
1482 # new_image = self.glancev1.images.create(name=image_dict["name"], is_public=
1483 # image_dict.get("public","yes")=="yes",
1484 # container_format="bare", data=fimage, disk_format=disk_format)
1486 metadata_to_load
= image_dict
.get("metadata")
1488 # TODO location is a reserved word for current openstack versions. fixed for VIO please check
1490 if self
.vim_type
== "VIO":
1491 metadata_to_load
["upload_location"] = image_dict
["location"]
1493 metadata_to_load
["location"] = image_dict
["location"]
1495 self
.glance
.images
.update(new_image
.id, **metadata_to_load
)
1499 nvExceptions
.Conflict
,
1500 ksExceptions
.ClientException
,
1501 nvExceptions
.ClientException
,
1503 self
._format
_exception
(e
)
1506 gl1Exceptions
.HTTPException
,
1507 gl1Exceptions
.CommunicationError
,
1510 if retry
== max_retries
:
1513 self
._format
_exception
(e
)
1514 except IOError as e
: # can not open the file
1515 raise vimconn
.VimConnConnectionException(
1516 "{}: {} for {}".format(type(e
).__name
__, e
, image_dict
["location"]),
1517 http_code
=vimconn
.HTTP_Bad_Request
,
1520 def delete_image(self
, image_id
):
1521 """Deletes a tenant image from openstack VIM. Returns the old id"""
1523 self
._reload
_connection
()
1524 self
.glance
.images
.delete(image_id
)
1528 nvExceptions
.NotFound
,
1529 ksExceptions
.ClientException
,
1530 nvExceptions
.ClientException
,
1531 gl1Exceptions
.CommunicationError
,
1532 gl1Exceptions
.HTTPNotFound
,
1534 ) as e
: # TODO remove
1535 self
._format
_exception
(e
)
1537 def get_image_id_from_path(self
, path
):
1538 """Get the image id from image path in the VIM database. Returns the image_id"""
1540 self
._reload
_connection
()
1541 images
= self
.glance
.images
.list()
1543 for image
in images
:
1544 if image
.metadata
.get("location") == path
:
1547 raise vimconn
.VimConnNotFoundException(
1548 "image with location '{}' not found".format(path
)
1551 ksExceptions
.ClientException
,
1552 nvExceptions
.ClientException
,
1553 gl1Exceptions
.CommunicationError
,
1556 self
._format
_exception
(e
)
1558 def get_image_list(self
, filter_dict
={}):
1559 """Obtain tenant images from VIM
1563 checksum: image checksum
1564 Returns the image list of dictionaries:
1565 [{<the fields at Filter_dict plus some VIM specific>}, ...]
1568 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
1571 self
._reload
_connection
()
1572 # filter_dict_os = filter_dict.copy()
1573 # First we filter by the available filter fields: name, id. The others are removed.
1574 image_list
= self
.glance
.images
.list()
1577 for image
in image_list
:
1579 if filter_dict
.get("name") and image
["name"] != filter_dict
["name"]:
1582 if filter_dict
.get("id") and image
["id"] != filter_dict
["id"]:
1586 filter_dict
.get("checksum")
1587 and image
["checksum"] != filter_dict
["checksum"]
1591 filtered_list
.append(image
.copy())
1592 except gl1Exceptions
.HTTPNotFound
:
1595 return filtered_list
1597 ksExceptions
.ClientException
,
1598 nvExceptions
.ClientException
,
1599 gl1Exceptions
.CommunicationError
,
1602 self
._format
_exception
(e
)
1604 def __wait_for_vm(self
, vm_id
, status
):
1605 """wait until vm is in the desired status and return True.
1606 If the VM gets in ERROR status, return false.
1607 If the timeout is reached generate an exception"""
1609 while elapsed_time
< server_timeout
:
1610 vm_status
= self
.nova
.servers
.get(vm_id
).status
1612 if vm_status
== status
:
1615 if vm_status
== "ERROR":
1621 # if we exceeded the timeout rollback
1622 if elapsed_time
>= server_timeout
:
1623 raise vimconn
.VimConnException(
1624 "Timeout waiting for instance " + vm_id
+ " to get " + status
,
1625 http_code
=vimconn
.HTTP_Request_Timeout
,
1628 def _get_openstack_availablity_zones(self
):
1630 Get from openstack availability zones available
1634 openstack_availability_zone
= self
.nova
.availability_zones
.list()
1635 openstack_availability_zone
= [
1637 for zone
in openstack_availability_zone
1638 if zone
.zoneName
!= "internal"
1641 return openstack_availability_zone
1645 def _set_availablity_zones(self
):
1647 Set vim availablity zone
1650 if "availability_zone" in self
.config
:
1651 vim_availability_zones
= self
.config
.get("availability_zone")
1653 if isinstance(vim_availability_zones
, str):
1654 self
.availability_zone
= [vim_availability_zones
]
1655 elif isinstance(vim_availability_zones
, list):
1656 self
.availability_zone
= vim_availability_zones
1658 self
.availability_zone
= self
._get
_openstack
_availablity
_zones
()
1660 def _get_vm_availability_zone(
1661 self
, availability_zone_index
, availability_zone_list
1664 Return thge availability zone to be used by the created VM.
1665 :return: The VIM availability zone to be used or None
1667 if availability_zone_index
is None:
1668 if not self
.config
.get("availability_zone"):
1670 elif isinstance(self
.config
.get("availability_zone"), str):
1671 return self
.config
["availability_zone"]
1673 # TODO consider using a different parameter at config for default AV and AV list match
1674 return self
.config
["availability_zone"][0]
1676 vim_availability_zones
= self
.availability_zone
1677 # check if VIM offer enough availability zones describe in the VNFD
1678 if vim_availability_zones
and len(availability_zone_list
) <= len(
1679 vim_availability_zones
1681 # check if all the names of NFV AV match VIM AV names
1682 match_by_index
= False
1683 for av
in availability_zone_list
:
1684 if av
not in vim_availability_zones
:
1685 match_by_index
= True
1689 return vim_availability_zones
[availability_zone_index
]
1691 return availability_zone_list
[availability_zone_index
]
1693 raise vimconn
.VimConnConflictException(
1694 "No enough availability zones at VIM for this deployment"
1704 affinity_group_list
,
1708 availability_zone_index
=None,
1709 availability_zone_list
=None,
1711 """Adds a VM instance to VIM
1713 start: indicates if VM must start or boot in pause mode. Ignored
1714 image_id,flavor_id: image and flavor uuid
1715 affinity_group_list: list of affinity groups, each one is a dictionary.
1717 net_list: list of interfaces, each one is a dictionary with:
1719 net_id: network uuid to connect
1720 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
1721 model: interface model, ignored #TODO
1722 mac_address: used for SR-IOV ifaces #TODO for other types
1723 use: 'data', 'bridge', 'mgmt'
1724 type: 'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
1725 vim_id: filled/added by this function
1726 floating_ip: True/False (or it can be None)
1727 port_security: True/False
1728 'cloud_config': (optional) dictionary with:
1729 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
1730 'users': (optional) list of users to be inserted, each item is a dict with:
1731 'name': (mandatory) user name,
1732 'key-pairs': (optional) list of strings with the public key to be inserted to the user
1733 'user-data': (optional) string is a text script to be passed directly to cloud-init
1734 'config-files': (optional). List of files to be transferred. Each item is a dict with:
1735 'dest': (mandatory) string with the destination absolute path
1736 'encoding': (optional, by default text). Can be one of:
1737 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
1738 'content' (mandatory): string with the content of the file
1739 'permissions': (optional) string with file permissions, typically octal notation '0644'
1740 'owner': (optional) file owner, string with the format 'owner:group'
1741 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
1742 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
1743 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
1744 'size': (mandatory) string with the size of the disk in GB
1745 'vim_id' (optional) should use this existing volume id
1746 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
1747 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
1748 availability_zone_index is None
1749 #TODO ip, security groups
1750 Returns a tuple with the instance identifier and created_items or raises an exception on error
1751 created_items can be None or a dictionary where this method can include key-values that will be passed to
1752 the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
1753 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
1757 "new_vminstance input: image='%s' flavor='%s' nics='%s'",
1768 external_network
= []
1769 # ^list of external networks to be connected to instance, later on used to create floating_ip
1770 no_secured_ports
= [] # List of port-is with port-security disabled
1771 self
._reload
_connection
()
1772 # metadata_vpci = {} # For a specific neutron plugin
1773 block_device_mapping
= None
1775 for net
in net_list
:
1776 if not net
.get("net_id"): # skip non connected iface
1780 "network_id": net
["net_id"],
1781 "name": net
.get("name"),
1782 "admin_state_up": True,
1786 self
.config
.get("security_groups")
1787 and net
.get("port_security") is not False
1788 and not self
.config
.get("no_port_security_extension")
1790 if not self
.security_groups_id
:
1791 self
._get
_ids
_from
_name
()
1793 port_dict
["security_groups"] = self
.security_groups_id
1795 if net
["type"] == "virtual":
1798 # metadata_vpci[ net["net_id"] ] = [[ net["vpci"], "" ]]
1799 elif net
["type"] == "VF" or net
["type"] == "SR-IOV": # for VF
1801 # if "VF" not in metadata_vpci:
1802 # metadata_vpci["VF"]=[]
1803 # metadata_vpci["VF"].append([ net["vpci"], "" ])
1804 port_dict
["binding:vnic_type"] = "direct"
1806 # VIO specific Changes
1807 if self
.vim_type
== "VIO":
1808 # Need to create port with port_security_enabled = False and no-security-groups
1809 port_dict
["port_security_enabled"] = False
1810 port_dict
["provider_security_groups"] = []
1811 port_dict
["security_groups"] = []
1812 else: # For PT PCI-PASSTHROUGH
1814 # if "PF" not in metadata_vpci:
1815 # metadata_vpci["PF"]=[]
1816 # metadata_vpci["PF"].append([ net["vpci"], "" ])
1817 port_dict
["binding:vnic_type"] = "direct-physical"
1819 if not port_dict
["name"]:
1820 port_dict
["name"] = name
1822 if net
.get("mac_address"):
1823 port_dict
["mac_address"] = net
["mac_address"]
1825 if net
.get("ip_address"):
1826 port_dict
["fixed_ips"] = [{"ip_address": net
["ip_address"]}]
1827 # TODO add "subnet_id": <subnet_id>
1829 new_port
= self
.neutron
.create_port({"port": port_dict
})
1830 created_items
["port:" + str(new_port
["port"]["id"])] = True
1831 net
["mac_adress"] = new_port
["port"]["mac_address"]
1832 net
["vim_id"] = new_port
["port"]["id"]
1833 # if try to use a network without subnetwork, it will return a emtpy list
1834 fixed_ips
= new_port
["port"].get("fixed_ips")
1837 net
["ip"] = fixed_ips
[0].get("ip_address")
1841 port
= {"port-id": new_port
["port"]["id"]}
1842 if float(self
.nova
.api_version
.get_string()) >= 2.32:
1843 port
["tag"] = new_port
["port"]["name"]
1845 net_list_vim
.append(port
)
1847 if net
.get("floating_ip", False):
1848 net
["exit_on_floating_ip_error"] = True
1849 external_network
.append(net
)
1850 elif net
["use"] == "mgmt" and self
.config
.get("use_floating_ip"):
1851 net
["exit_on_floating_ip_error"] = False
1852 external_network
.append(net
)
1853 net
["floating_ip"] = self
.config
.get("use_floating_ip")
1855 # If port security is disabled when the port has not yet been attached to the VM, then all vm traffic
1857 # As a workaround we wait until the VM is active and then disable the port-security
1858 if net
.get("port_security") is False and not self
.config
.get(
1859 "no_port_security_extension"
1861 no_secured_ports
.append(
1863 new_port
["port"]["id"],
1864 net
.get("port_security_disable_strategy"),
1869 # metadata = {"pci_assignement": json.dumps(metadata_vpci)}
1870 # if len(metadata["pci_assignement"]) >255:
1871 # #limit the metadata size
1872 # #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
1873 # self.logger.warn("Metadata deleted since it exceeds the expected length (255) ")
1877 "name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s'",
1886 config_drive
, userdata
= self
._create
_user
_data
(cloud_config
)
1888 # get availability Zone
1889 vm_av_zone
= self
._get
_vm
_availability
_zone
(
1890 availability_zone_index
, availability_zone_list
1893 # Create additional volumes in case these are present in disk_list
1894 existing_vim_volumes
= []
1895 base_disk_index
= ord("b")
1896 boot_volume_id
= None
1898 block_device_mapping
= {}
1899 for disk
in disk_list
:
1900 if "image_id" in disk
:
1901 # persistent root volume
1902 base_disk_index
= ord("a")
1904 # use existing persistent root volume
1905 if disk
.get("vim_volume_id"):
1906 block_device_mapping
["vd" + chr(base_disk_index
)] = disk
[
1909 existing_vim_volumes
.append({"id": disk
["vim_volume_id"]})
1910 # use existing persistent root volume
1911 elif disk
.get("vim_id"):
1912 block_device_mapping
["vd" + chr(base_disk_index
)] = disk
[
1915 existing_vim_volumes
.append({"id": disk
["vim_id"]})
1917 # create persistent root volume
1918 volume
= self
.cinder
.volumes
.create(
1920 name
=name
+ "vd" + chr(base_disk_index
),
1921 imageRef
=disk
["image_id"],
1922 # Make sure volume is in the same AZ as the VM to be attached to
1923 availability_zone
=vm_av_zone
,
1925 boot_volume_id
= volume
.id
1926 created_items
["volume:" + str(volume
.id)] = True
1927 block_device_mapping
[
1928 "vd" + chr(base_disk_index
)
1931 # non-root persistent volume
1934 if "vim_volume_id" in disk
.keys()
1937 if disk
.get(key_id
):
1938 # use existing persistent volume
1939 block_device_mapping
["vd" + chr(base_disk_index
)] = disk
[
1942 existing_vim_volumes
.append({"id": disk
[key_id
]})
1944 # create persistent volume
1945 volume
= self
.cinder
.volumes
.create(
1947 name
=name
+ "vd" + chr(base_disk_index
),
1948 # Make sure volume is in the same AZ as the VM to be attached to
1949 availability_zone
=vm_av_zone
,
1951 created_items
["volume:" + str(volume
.id)] = True
1952 block_device_mapping
[
1953 "vd" + chr(base_disk_index
)
1956 base_disk_index
+= 1
1958 # Wait until created volumes are with status available
1960 while elapsed_time
< volume_timeout
:
1961 for created_item
in created_items
:
1962 v
, _
, volume_id
= created_item
.partition(":")
1964 if self
.cinder
.volumes
.get(volume_id
).status
!= "available":
1966 else: # all ready: break from while
1972 # Wait until existing volumes in vim are with status available
1973 while elapsed_time
< volume_timeout
:
1974 for volume
in existing_vim_volumes
:
1975 if self
.cinder
.volumes
.get(volume
["id"]).status
!= "available":
1977 else: # all ready: break from while
1983 # If we exceeded the timeout rollback
1984 if elapsed_time
>= volume_timeout
:
1985 raise vimconn
.VimConnException(
1986 "Timeout creating volumes for instance " + name
,
1987 http_code
=vimconn
.HTTP_Request_Timeout
,
1990 self
.cinder
.volumes
.set_bootable(boot_volume_id
, True)
1992 # Manage affinity groups/server groups
1993 server_group_id
= None
1994 scheduller_hints
= {}
1996 if affinity_group_list
:
1997 # Only first id on the list will be used. Openstack restriction
1998 server_group_id
= affinity_group_list
[0]["affinity_group_id"]
1999 scheduller_hints
["group"] = server_group_id
2002 "nova.servers.create({}, {}, {}, nics={}, security_groups={}, "
2003 "availability_zone={}, key_name={}, userdata={}, config_drive={}, "
2004 "block_device_mapping={}, server_group={})".format(
2009 self
.config
.get("security_groups"),
2011 self
.config
.get("keypair"),
2014 block_device_mapping
,
2018 server
= self
.nova
.servers
.create(
2023 security_groups
=self
.config
.get("security_groups"),
2024 # TODO remove security_groups in future versions. Already at neutron port
2025 availability_zone
=vm_av_zone
,
2026 key_name
=self
.config
.get("keypair"),
2028 config_drive
=config_drive
,
2029 block_device_mapping
=block_device_mapping
,
2030 scheduler_hints
=scheduller_hints
,
2031 ) # , description=description)
2033 vm_start_time
= time
.time()
2034 # Previously mentioned workaround to wait until the VM is active and then disable the port-security
2035 if no_secured_ports
:
2036 self
.__wait
_for
_vm
(server
.id, "ACTIVE")
2038 for port
in no_secured_ports
:
2040 "port": {"port_security_enabled": False, "security_groups": None}
2043 if port
[1] == "allow-address-pairs":
2045 "port": {"allowed_address_pairs": [{"ip_address": "0.0.0.0/0"}]}
2049 self
.neutron
.update_port(port
[0], port_update
)
2051 raise vimconn
.VimConnException(
2052 "It was not possible to disable port security for port {}".format(
2057 # print "DONE :-)", server
2060 for floating_network
in external_network
:
2063 floating_ip_retries
= 3
2064 # In case of RO in HA there can be conflicts, two RO trying to assign same floating IP, so retry
2067 floating_ips
= self
.neutron
.list_floatingips().get(
2070 random
.shuffle(floating_ips
) # randomize
2071 for fip
in floating_ips
:
2074 or fip
.get("tenant_id") != server
.tenant_id
2078 if isinstance(floating_network
["floating_ip"], str):
2080 fip
.get("floating_network_id")
2081 != floating_network
["floating_ip"]
2085 free_floating_ip
= fip
["id"]
2089 isinstance(floating_network
["floating_ip"], str)
2090 and floating_network
["floating_ip"].lower() != "true"
2092 pool_id
= floating_network
["floating_ip"]
2094 # Find the external network
2095 external_nets
= list()
2097 for net
in self
.neutron
.list_networks()["networks"]:
2098 if net
["router:external"]:
2099 external_nets
.append(net
)
2101 if len(external_nets
) == 0:
2102 raise vimconn
.VimConnException(
2103 "Cannot create floating_ip automatically since "
2104 "no external network is present",
2105 http_code
=vimconn
.HTTP_Conflict
,
2108 if len(external_nets
) > 1:
2109 raise vimconn
.VimConnException(
2110 "Cannot create floating_ip automatically since "
2111 "multiple external networks are present",
2112 http_code
=vimconn
.HTTP_Conflict
,
2115 pool_id
= external_nets
[0].get("id")
2119 "floating_network_id": pool_id
,
2120 "tenant_id": server
.tenant_id
,
2125 # self.logger.debug("Creating floating IP")
2126 new_floating_ip
= self
.neutron
.create_floatingip(param
)
2127 free_floating_ip
= new_floating_ip
["floatingip"]["id"]
2129 "floating_ip:" + str(free_floating_ip
)
2131 except Exception as e
:
2132 raise vimconn
.VimConnException(
2134 + ": Cannot create new floating_ip "
2136 http_code
=vimconn
.HTTP_Conflict
,
2140 # for race condition ensure not already assigned
2141 fip
= self
.neutron
.show_floatingip(free_floating_ip
)
2143 if fip
["floatingip"]["port_id"]:
2146 # the vim_id key contains the neutron.port_id
2147 self
.neutron
.update_floatingip(
2149 {"floatingip": {"port_id": floating_network
["vim_id"]}},
2151 # for race condition ensure not re-assigned to other VM after 5 seconds
2153 fip
= self
.neutron
.show_floatingip(free_floating_ip
)
2156 fip
["floatingip"]["port_id"]
2157 != floating_network
["vim_id"]
2160 "floating_ip {} re-assigned to other port".format(
2167 "Assigned floating_ip {} to VM {}".format(
2168 free_floating_ip
, server
.id
2172 except Exception as e
:
2173 # openstack need some time after VM creation to assign an IP. So retry if fails
2174 vm_status
= self
.nova
.servers
.get(server
.id).status
2176 if vm_status
not in ("ACTIVE", "ERROR"):
2177 if time
.time() - vm_start_time
< server_timeout
:
2180 elif floating_ip_retries
> 0:
2181 floating_ip_retries
-= 1
2184 raise vimconn
.VimConnException(
2185 "Cannot create floating_ip: {} {}".format(
2188 http_code
=vimconn
.HTTP_Conflict
,
2191 except Exception as e
:
2192 if not floating_network
["exit_on_floating_ip_error"]:
2193 self
.logger
.error("Cannot create floating_ip. %s", str(e
))
2198 return server
.id, created_items
2199 # except nvExceptions.NotFound as e:
2200 # error_value=-vimconn.HTTP_Not_Found
2201 # error_text= "vm instance %s not found" % vm_id
2202 # except TypeError as e:
2203 # raise vimconn.VimConnException(type(e).__name__ + ": "+ str(e), http_code=vimconn.HTTP_Bad_Request)
2205 except Exception as e
:
2208 server_id
= server
.id
2211 self
.delete_vminstance(server_id
, created_items
)
2212 except Exception as e2
:
2213 self
.logger
.error("new_vminstance rollback fail {}".format(e2
))
2215 self
._format
_exception
(e
)
2217 def get_vminstance(self
, vm_id
):
2218 """Returns the VM instance information from VIM"""
2219 # self.logger.debug("Getting VM from VIM")
2221 self
._reload
_connection
()
2222 server
= self
.nova
.servers
.find(id=vm_id
)
2223 # TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
2225 return server
.to_dict()
2227 ksExceptions
.ClientException
,
2228 nvExceptions
.ClientException
,
2229 nvExceptions
.NotFound
,
2232 self
._format
_exception
(e
)
2234 def get_vminstance_console(self
, vm_id
, console_type
="vnc"):
2236 Get a console for the virtual machine
2238 vm_id: uuid of the VM
2239 console_type, can be:
2240 "novnc" (by default), "xvpvnc" for VNC types,
2241 "rdp-html5" for RDP types, "spice-html5" for SPICE types
2242 Returns dict with the console parameters:
2243 protocol: ssh, ftp, http, https, ...
2244 server: usually ip address
2245 port: the http, ssh, ... port
2246 suffix: extra text, e.g. the http path and query string
2248 self
.logger
.debug("Getting VM CONSOLE from VIM")
2251 self
._reload
_connection
()
2252 server
= self
.nova
.servers
.find(id=vm_id
)
2254 if console_type
is None or console_type
== "novnc":
2255 console_dict
= server
.get_vnc_console("novnc")
2256 elif console_type
== "xvpvnc":
2257 console_dict
= server
.get_vnc_console(console_type
)
2258 elif console_type
== "rdp-html5":
2259 console_dict
= server
.get_rdp_console(console_type
)
2260 elif console_type
== "spice-html5":
2261 console_dict
= server
.get_spice_console(console_type
)
2263 raise vimconn
.VimConnException(
2264 "console type '{}' not allowed".format(console_type
),
2265 http_code
=vimconn
.HTTP_Bad_Request
,
2268 console_dict1
= console_dict
.get("console")
2271 console_url
= console_dict1
.get("url")
2275 protocol_index
= console_url
.find("//")
2277 console_url
[protocol_index
+ 2 :].find("/") + protocol_index
+ 2
2280 console_url
[protocol_index
+ 2 : suffix_index
].find(":")
2285 if protocol_index
< 0 or port_index
< 0 or suffix_index
< 0:
2287 -vimconn
.HTTP_Internal_Server_Error
,
2288 "Unexpected response from VIM",
2292 "protocol": console_url
[0:protocol_index
],
2293 "server": console_url
[protocol_index
+ 2 : port_index
],
2294 "port": console_url
[port_index
:suffix_index
],
2295 "suffix": console_url
[suffix_index
+ 1 :],
2300 raise vimconn
.VimConnUnexpectedResponse("Unexpected response from VIM")
2302 nvExceptions
.NotFound
,
2303 ksExceptions
.ClientException
,
2304 nvExceptions
.ClientException
,
2305 nvExceptions
.BadRequest
,
2308 self
._format
_exception
(e
)
2310 def delete_vminstance(self
, vm_id
, created_items
=None, volumes_to_hold
=None):
2311 """Removes a VM instance from VIM. Returns the old identifier"""
2312 # print "osconnector: Getting VM from VIM"
2313 if created_items
is None:
2317 self
._reload
_connection
()
2318 # delete VM ports attached to this networks before the virtual machine
2319 for k
, v
in created_items
.items():
2320 if not v
: # skip already deleted
2324 k_item
, _
, k_id
= k
.partition(":")
2325 if k_item
== "port":
2326 port_dict
= self
.neutron
.list_ports()
2328 port
["id"] for port
in port_dict
["ports"] if port_dict
2330 if k_id
in existing_ports
:
2331 self
.neutron
.delete_port(k_id
)
2332 except Exception as e
:
2334 "Error deleting port: {}: {}".format(type(e
).__name
__, e
)
2337 # #commented because detaching the volumes makes the servers.delete not work properly ?!?
2338 # #dettach volumes attached
2339 # server = self.nova.servers.get(vm_id)
2340 # volumes_attached_dict = server._info["os-extended-volumes:volumes_attached"] #volume["id"]
2341 # #for volume in volumes_attached_dict:
2342 # # self.cinder.volumes.detach(volume["id"])
2345 self
.nova
.servers
.delete(vm_id
)
2347 # delete volumes. Although having detached, they should have in active status before deleting
2348 # we ensure in this loop
2352 while keep_waiting
and elapsed_time
< volume_timeout
:
2353 keep_waiting
= False
2355 for k
, v
in created_items
.items():
2356 if not v
: # skip already deleted
2360 k_item
, _
, k_id
= k
.partition(":")
2361 if k_item
== "volume":
2362 if self
.cinder
.volumes
.get(k_id
).status
!= "available":
2365 if k_id
not in volumes_to_hold
:
2366 self
.cinder
.volumes
.delete(k_id
)
2367 created_items
[k
] = None
2368 elif k_item
== "floating_ip": # floating ip
2369 self
.neutron
.delete_floatingip(k_id
)
2370 created_items
[k
] = None
2372 except Exception as e
:
2373 self
.logger
.error("Error deleting {}: {}".format(k
, e
))
2381 nvExceptions
.NotFound
,
2382 ksExceptions
.ClientException
,
2383 nvExceptions
.ClientException
,
2386 self
._format
_exception
(e
)
2388 def refresh_vms_status(self
, vm_list
):
2389 """Get the status of the virtual machines and their interfaces/ports
2390 Params: the list of VM identifiers
2391 Returns a dictionary with:
2392 vm_id: #VIM id of this Virtual Machine
2393 status: #Mandatory. Text with one of:
2394 # DELETED (not found at vim)
2395 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
2396 # OTHER (Vim reported other status not understood)
2397 # ERROR (VIM indicates an ERROR status)
2398 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
2399 # CREATING (on building process), ERROR
2400 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
2402 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
2403 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
2405 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
2406 mac_address: #Text format XX:XX:XX:XX:XX:XX
2407 vim_net_id: #network id where this interface is connected
2408 vim_interface_id: #interface/port VIM id
2409 ip_address: #null, or text with IPv4, IPv6 address
2410 compute_node: #identification of compute node where PF,VF interface is allocated
2411 pci: #PCI address of the NIC that hosts the PF,VF
2412 vlan: #physical VLAN used for VF
2416 "refresh_vms status: Getting tenant VM instance information from VIM"
2419 for vm_id
in vm_list
:
2423 vm_vim
= self
.get_vminstance(vm_id
)
2425 if vm_vim
["status"] in vmStatus2manoFormat
:
2426 vm
["status"] = vmStatus2manoFormat
[vm_vim
["status"]]
2428 vm
["status"] = "OTHER"
2429 vm
["error_msg"] = "VIM status reported " + vm_vim
["status"]
2431 vm_vim
.pop("OS-EXT-SRV-ATTR:user_data", None)
2432 vm_vim
.pop("user_data", None)
2433 vm
["vim_info"] = self
.serialize(vm_vim
)
2435 vm
["interfaces"] = []
2436 if vm_vim
.get("fault"):
2437 vm
["error_msg"] = str(vm_vim
["fault"])
2441 self
._reload
_connection
()
2442 port_dict
= self
.neutron
.list_ports(device_id
=vm_id
)
2444 for port
in port_dict
["ports"]:
2446 interface
["vim_info"] = self
.serialize(port
)
2447 interface
["mac_address"] = port
.get("mac_address")
2448 interface
["vim_net_id"] = port
["network_id"]
2449 interface
["vim_interface_id"] = port
["id"]
2450 # check if OS-EXT-SRV-ATTR:host is there,
2451 # in case of non-admin credentials, it will be missing
2453 if vm_vim
.get("OS-EXT-SRV-ATTR:host"):
2454 interface
["compute_node"] = vm_vim
["OS-EXT-SRV-ATTR:host"]
2456 interface
["pci"] = None
2458 # check if binding:profile is there,
2459 # in case of non-admin credentials, it will be missing
2460 if port
.get("binding:profile"):
2461 if port
["binding:profile"].get("pci_slot"):
2462 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting
2464 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
2465 # CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2) assuming there are 2 ports per nic
2466 pci
= port
["binding:profile"]["pci_slot"]
2467 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
2468 interface
["pci"] = pci
2470 interface
["vlan"] = None
2472 if port
.get("binding:vif_details"):
2473 interface
["vlan"] = port
["binding:vif_details"].get("vlan")
2475 # Get vlan from network in case not present in port for those old openstacks and cases where
2476 # it is needed vlan at PT
2477 if not interface
["vlan"]:
2478 # if network is of type vlan and port is of type direct (sr-iov) then set vlan id
2479 network
= self
.neutron
.show_network(port
["network_id"])
2482 network
["network"].get("provider:network_type")
2485 # and port.get("binding:vnic_type") in ("direct", "direct-physical"):
2486 interface
["vlan"] = network
["network"].get(
2487 "provider:segmentation_id"
2491 # look for floating ip address
2493 floating_ip_dict
= self
.neutron
.list_floatingips(
2497 if floating_ip_dict
.get("floatingips"):
2499 floating_ip_dict
["floatingips"][0].get(
2500 "floating_ip_address"
2506 for subnet
in port
["fixed_ips"]:
2507 ips
.append(subnet
["ip_address"])
2509 interface
["ip_address"] = ";".join(ips
)
2510 vm
["interfaces"].append(interface
)
2511 except Exception as e
:
2513 "Error getting vm interface information {}: {}".format(
2518 except vimconn
.VimConnNotFoundException
as e
:
2519 self
.logger
.error("Exception getting vm status: %s", str(e
))
2520 vm
["status"] = "DELETED"
2521 vm
["error_msg"] = str(e
)
2522 except vimconn
.VimConnException
as e
:
2523 self
.logger
.error("Exception getting vm status: %s", str(e
))
2524 vm
["status"] = "VIM_ERROR"
2525 vm
["error_msg"] = str(e
)
2531 def action_vminstance(self
, vm_id
, action_dict
, created_items
={}):
2532 """Send and action over a VM instance from VIM
2533 Returns None or the console dict if the action was successfully sent to the VIM"""
2534 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
2537 self
._reload
_connection
()
2538 server
= self
.nova
.servers
.find(id=vm_id
)
2540 if "start" in action_dict
:
2541 if action_dict
["start"] == "rebuild":
2544 if server
.status
== "PAUSED":
2546 elif server
.status
== "SUSPENDED":
2548 elif server
.status
== "SHUTOFF":
2552 "ERROR : Instance is not in SHUTOFF/PAUSE/SUSPEND state"
2554 raise vimconn
.VimConnException(
2555 "Cannot 'start' instance while it is in active state",
2556 http_code
=vimconn
.HTTP_Bad_Request
,
2559 elif "pause" in action_dict
:
2561 elif "resume" in action_dict
:
2563 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
2564 self
.logger
.debug("server status %s", server
.status
)
2565 if server
.status
== "ACTIVE":
2568 self
.logger
.debug("ERROR: VM is not in Active state")
2569 raise vimconn
.VimConnException(
2570 "VM is not in active state, stop operation is not allowed",
2571 http_code
=vimconn
.HTTP_Bad_Request
,
2573 elif "forceOff" in action_dict
:
2574 server
.stop() # TODO
2575 elif "terminate" in action_dict
:
2577 elif "createImage" in action_dict
:
2578 server
.create_image()
2579 # "path":path_schema,
2580 # "description":description_schema,
2581 # "name":name_schema,
2582 # "metadata":metadata_schema,
2583 # "imageRef": id_schema,
2584 # "disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
2585 elif "rebuild" in action_dict
:
2586 server
.rebuild(server
.image
["id"])
2587 elif "reboot" in action_dict
:
2588 server
.reboot() # reboot_type="SOFT"
2589 elif "console" in action_dict
:
2590 console_type
= action_dict
["console"]
2592 if console_type
is None or console_type
== "novnc":
2593 console_dict
= server
.get_vnc_console("novnc")
2594 elif console_type
== "xvpvnc":
2595 console_dict
= server
.get_vnc_console(console_type
)
2596 elif console_type
== "rdp-html5":
2597 console_dict
= server
.get_rdp_console(console_type
)
2598 elif console_type
== "spice-html5":
2599 console_dict
= server
.get_spice_console(console_type
)
2601 raise vimconn
.VimConnException(
2602 "console type '{}' not allowed".format(console_type
),
2603 http_code
=vimconn
.HTTP_Bad_Request
,
2607 console_url
= console_dict
["console"]["url"]
2609 protocol_index
= console_url
.find("//")
2611 console_url
[protocol_index
+ 2 :].find("/") + protocol_index
+ 2
2614 console_url
[protocol_index
+ 2 : suffix_index
].find(":")
2619 if protocol_index
< 0 or port_index
< 0 or suffix_index
< 0:
2620 raise vimconn
.VimConnException(
2621 "Unexpected response from VIM " + str(console_dict
)
2625 "protocol": console_url
[0:protocol_index
],
2626 "server": console_url
[protocol_index
+ 2 : port_index
],
2627 "port": int(console_url
[port_index
+ 1 : suffix_index
]),
2628 "suffix": console_url
[suffix_index
+ 1 :],
2631 return console_dict2
2633 raise vimconn
.VimConnException(
2634 "Unexpected response from VIM " + str(console_dict
)
2639 ksExceptions
.ClientException
,
2640 nvExceptions
.ClientException
,
2641 nvExceptions
.NotFound
,
2644 self
._format
_exception
(e
)
2645 # TODO insert exception vimconn.HTTP_Unauthorized
2647 # ###### VIO Specific Changes #########
2648 def _generate_vlanID(self
):
2650 Method to get unused vlanID
2658 networks
= self
.get_network_list()
2660 for net
in networks
:
2661 if net
.get("provider:segmentation_id"):
2662 usedVlanIDs
.append(net
.get("provider:segmentation_id"))
2664 used_vlanIDs
= set(usedVlanIDs
)
2666 # find unused VLAN ID
2667 for vlanID_range
in self
.config
.get("dataplane_net_vlan_range"):
2669 start_vlanid
, end_vlanid
= map(
2670 int, vlanID_range
.replace(" ", "").split("-")
2673 for vlanID
in range(start_vlanid
, end_vlanid
+ 1):
2674 if vlanID
not in used_vlanIDs
:
2676 except Exception as exp
:
2677 raise vimconn
.VimConnException(
2678 "Exception {} occurred while generating VLAN ID.".format(exp
)
2681 raise vimconn
.VimConnConflictException(
2682 "Unable to create the SRIOV VLAN network. All given Vlan IDs {} are in use.".format(
2683 self
.config
.get("dataplane_net_vlan_range")
2687 def _generate_multisegment_vlanID(self
):
2689 Method to get unused vlanID
2697 networks
= self
.get_network_list()
2698 for net
in networks
:
2699 if net
.get("provider:network_type") == "vlan" and net
.get(
2700 "provider:segmentation_id"
2702 usedVlanIDs
.append(net
.get("provider:segmentation_id"))
2703 elif net
.get("segments"):
2704 for segment
in net
.get("segments"):
2705 if segment
.get("provider:network_type") == "vlan" and segment
.get(
2706 "provider:segmentation_id"
2708 usedVlanIDs
.append(segment
.get("provider:segmentation_id"))
2710 used_vlanIDs
= set(usedVlanIDs
)
2712 # find unused VLAN ID
2713 for vlanID_range
in self
.config
.get("multisegment_vlan_range"):
2715 start_vlanid
, end_vlanid
= map(
2716 int, vlanID_range
.replace(" ", "").split("-")
2719 for vlanID
in range(start_vlanid
, end_vlanid
+ 1):
2720 if vlanID
not in used_vlanIDs
:
2722 except Exception as exp
:
2723 raise vimconn
.VimConnException(
2724 "Exception {} occurred while generating VLAN ID.".format(exp
)
2727 raise vimconn
.VimConnConflictException(
2728 "Unable to create the VLAN segment. All VLAN IDs {} are in use.".format(
2729 self
.config
.get("multisegment_vlan_range")
2733 def _validate_vlan_ranges(self
, input_vlan_range
, text_vlan_range
):
2735 Method to validate user given vlanID ranges
2739 for vlanID_range
in input_vlan_range
:
2740 vlan_range
= vlanID_range
.replace(" ", "")
2742 vlanID_pattern
= r
"(\d)*-(\d)*$"
2743 match_obj
= re
.match(vlanID_pattern
, vlan_range
)
2745 raise vimconn
.VimConnConflictException(
2746 "Invalid VLAN range for {}: {}.You must provide "
2747 "'{}' in format [start_ID - end_ID].".format(
2748 text_vlan_range
, vlanID_range
, text_vlan_range
2752 start_vlanid
, end_vlanid
= map(int, vlan_range
.split("-"))
2753 if start_vlanid
<= 0:
2754 raise vimconn
.VimConnConflictException(
2755 "Invalid VLAN range for {}: {}. Start ID can not be zero. For VLAN "
2756 "networks valid IDs are 1 to 4094 ".format(
2757 text_vlan_range
, vlanID_range
2761 if end_vlanid
> 4094:
2762 raise vimconn
.VimConnConflictException(
2763 "Invalid VLAN range for {}: {}. End VLAN ID can not be "
2764 "greater than 4094. For VLAN networks valid IDs are 1 to 4094 ".format(
2765 text_vlan_range
, vlanID_range
2769 if start_vlanid
> end_vlanid
:
2770 raise vimconn
.VimConnConflictException(
2771 "Invalid VLAN range for {}: {}. You must provide '{}'"
2772 " in format start_ID - end_ID and start_ID < end_ID ".format(
2773 text_vlan_range
, vlanID_range
, text_vlan_range
2777 # NOT USED FUNCTIONS
2779 def new_external_port(self
, port_data
):
2780 """Adds a external port to VIM
2781 Returns the port identifier"""
2782 # TODO openstack if needed
2784 -vimconn
.HTTP_Internal_Server_Error
,
2785 "osconnector.new_external_port() not implemented",
2788 def connect_port_network(self
, port_id
, network_id
, admin
=False):
2789 """Connects a external port to a network
2790 Returns status code of the VIM response"""
2791 # TODO openstack if needed
2793 -vimconn
.HTTP_Internal_Server_Error
,
2794 "osconnector.connect_port_network() not implemented",
2797 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
2798 """Adds a new user to openstack VIM
2799 Returns the user identifier"""
2800 self
.logger
.debug("osconnector: Adding a new user to VIM")
2803 self
._reload
_connection
()
2804 user
= self
.keystone
.users
.create(
2805 user_name
, password
=user_passwd
, default_project
=tenant_id
2807 # self.keystone.tenants.add_user(self.k_creds["username"], #role)
2810 except ksExceptions
.ConnectionError
as e
:
2811 error_value
= -vimconn
.HTTP_Bad_Request
2815 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2817 except ksExceptions
.ClientException
as e
: # TODO remove
2818 error_value
= -vimconn
.HTTP_Bad_Request
2822 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2825 # TODO insert exception vimconn.HTTP_Unauthorized
2826 # if reaching here is because an exception
2827 self
.logger
.debug("new_user " + error_text
)
2829 return error_value
, error_text
2831 def delete_user(self
, user_id
):
2832 """Delete a user from openstack VIM
2833 Returns the user identifier"""
2835 print("osconnector: Deleting a user from VIM")
2838 self
._reload
_connection
()
2839 self
.keystone
.users
.delete(user_id
)
2842 except ksExceptions
.ConnectionError
as e
:
2843 error_value
= -vimconn
.HTTP_Bad_Request
2847 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2849 except ksExceptions
.NotFound
as e
:
2850 error_value
= -vimconn
.HTTP_Not_Found
2854 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2856 except ksExceptions
.ClientException
as e
: # TODO remove
2857 error_value
= -vimconn
.HTTP_Bad_Request
2861 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2864 # TODO insert exception vimconn.HTTP_Unauthorized
2865 # if reaching here is because an exception
2866 self
.logger
.debug("delete_tenant " + error_text
)
2868 return error_value
, error_text
2870 def get_hosts_info(self
):
2871 """Get the information of deployed hosts
2872 Returns the hosts content"""
2874 print("osconnector: Getting Host info from VIM")
2878 self
._reload
_connection
()
2879 hypervisors
= self
.nova
.hypervisors
.list()
2881 for hype
in hypervisors
:
2882 h_list
.append(hype
.to_dict())
2884 return 1, {"hosts": h_list
}
2885 except nvExceptions
.NotFound
as e
:
2886 error_value
= -vimconn
.HTTP_Not_Found
2887 error_text
= str(e
) if len(e
.args
) == 0 else str(e
.args
[0])
2888 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
2889 error_value
= -vimconn
.HTTP_Bad_Request
2893 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2896 # TODO insert exception vimconn.HTTP_Unauthorized
2897 # if reaching here is because an exception
2898 self
.logger
.debug("get_hosts_info " + error_text
)
2900 return error_value
, error_text
2902 def get_hosts(self
, vim_tenant
):
2903 """Get the hosts and deployed instances
2904 Returns the hosts content"""
2905 r
, hype_dict
= self
.get_hosts_info()
2910 hypervisors
= hype_dict
["hosts"]
2913 servers
= self
.nova
.servers
.list()
2914 for hype
in hypervisors
:
2915 for server
in servers
:
2917 server
.to_dict()["OS-EXT-SRV-ATTR:hypervisor_hostname"]
2918 == hype
["hypervisor_hostname"]
2921 hype
["vm"].append(server
.id)
2923 hype
["vm"] = [server
.id]
2926 except nvExceptions
.NotFound
as e
:
2927 error_value
= -vimconn
.HTTP_Not_Found
2928 error_text
= str(e
) if len(e
.args
) == 0 else str(e
.args
[0])
2929 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
2930 error_value
= -vimconn
.HTTP_Bad_Request
2934 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2937 # TODO insert exception vimconn.HTTP_Unauthorized
2938 # if reaching here is because an exception
2939 self
.logger
.debug("get_hosts " + error_text
)
2941 return error_value
, error_text
2943 def new_classification(self
, name
, ctype
, definition
):
2945 "Adding a new (Traffic) Classification to VIM, named %s", name
2950 self
._reload
_connection
()
2952 if ctype
not in supportedClassificationTypes
:
2953 raise vimconn
.VimConnNotSupportedException(
2954 "OpenStack VIM connector does not support provided "
2955 "Classification Type {}, supported ones are: {}".format(
2956 ctype
, supportedClassificationTypes
2960 if not self
._validate
_classification
(ctype
, definition
):
2961 raise vimconn
.VimConnException(
2962 "Incorrect Classification definition for the type specified."
2965 classification_dict
= definition
2966 classification_dict
["name"] = name
2967 new_class
= self
.neutron
.create_sfc_flow_classifier(
2968 {"flow_classifier": classification_dict
}
2971 return new_class
["flow_classifier"]["id"]
2973 neExceptions
.ConnectionFailed
,
2974 ksExceptions
.ClientException
,
2975 neExceptions
.NeutronException
,
2978 self
.logger
.error("Creation of Classification failed.")
2979 self
._format
_exception
(e
)
2981 def get_classification(self
, class_id
):
2982 self
.logger
.debug(" Getting Classification %s from VIM", class_id
)
2983 filter_dict
= {"id": class_id
}
2984 class_list
= self
.get_classification_list(filter_dict
)
2986 if len(class_list
) == 0:
2987 raise vimconn
.VimConnNotFoundException(
2988 "Classification '{}' not found".format(class_id
)
2990 elif len(class_list
) > 1:
2991 raise vimconn
.VimConnConflictException(
2992 "Found more than one Classification with this criteria"
2995 classification
= class_list
[0]
2997 return classification
2999 def get_classification_list(self
, filter_dict
={}):
3001 "Getting Classifications from VIM filter: '%s'", str(filter_dict
)
3005 filter_dict_os
= filter_dict
.copy()
3006 self
._reload
_connection
()
3008 if self
.api_version3
and "tenant_id" in filter_dict_os
:
3009 filter_dict_os
["project_id"] = filter_dict_os
.pop("tenant_id")
3011 classification_dict
= self
.neutron
.list_sfc_flow_classifiers(
3014 classification_list
= classification_dict
["flow_classifiers"]
3015 self
.__classification
_os
2mano
(classification_list
)
3017 return classification_list
3019 neExceptions
.ConnectionFailed
,
3020 ksExceptions
.ClientException
,
3021 neExceptions
.NeutronException
,
3024 self
._format
_exception
(e
)
3026 def delete_classification(self
, class_id
):
3027 self
.logger
.debug("Deleting Classification '%s' from VIM", class_id
)
3030 self
._reload
_connection
()
3031 self
.neutron
.delete_sfc_flow_classifier(class_id
)
3035 neExceptions
.ConnectionFailed
,
3036 neExceptions
.NeutronException
,
3037 ksExceptions
.ClientException
,
3038 neExceptions
.NeutronException
,
3041 self
._format
_exception
(e
)
3043 def new_sfi(self
, name
, ingress_ports
, egress_ports
, sfc_encap
=True):
3045 "Adding a new Service Function Instance to VIM, named '%s'", name
3050 self
._reload
_connection
()
3056 if len(ingress_ports
) != 1:
3057 raise vimconn
.VimConnNotSupportedException(
3058 "OpenStack VIM connector can only have 1 ingress port per SFI"
3061 if len(egress_ports
) != 1:
3062 raise vimconn
.VimConnNotSupportedException(
3063 "OpenStack VIM connector can only have 1 egress port per SFI"
3068 "ingress": ingress_ports
[0],
3069 "egress": egress_ports
[0],
3070 "service_function_parameters": {"correlation": correlation
},
3072 new_sfi
= self
.neutron
.create_sfc_port_pair({"port_pair": sfi_dict
})
3074 return new_sfi
["port_pair"]["id"]
3076 neExceptions
.ConnectionFailed
,
3077 ksExceptions
.ClientException
,
3078 neExceptions
.NeutronException
,
3083 self
.neutron
.delete_sfc_port_pair(new_sfi
["port_pair"]["id"])
3086 "Creation of Service Function Instance failed, with "
3087 "subsequent deletion failure as well."
3090 self
._format
_exception
(e
)
3092 def get_sfi(self
, sfi_id
):
3093 self
.logger
.debug("Getting Service Function Instance %s from VIM", sfi_id
)
3094 filter_dict
= {"id": sfi_id
}
3095 sfi_list
= self
.get_sfi_list(filter_dict
)
3097 if len(sfi_list
) == 0:
3098 raise vimconn
.VimConnNotFoundException(
3099 "Service Function Instance '{}' not found".format(sfi_id
)
3101 elif len(sfi_list
) > 1:
3102 raise vimconn
.VimConnConflictException(
3103 "Found more than one Service Function Instance with this criteria"
3110 def get_sfi_list(self
, filter_dict
={}):
3112 "Getting Service Function Instances from VIM filter: '%s'", str(filter_dict
)
3116 self
._reload
_connection
()
3117 filter_dict_os
= filter_dict
.copy()
3119 if self
.api_version3
and "tenant_id" in filter_dict_os
:
3120 filter_dict_os
["project_id"] = filter_dict_os
.pop("tenant_id")
3122 sfi_dict
= self
.neutron
.list_sfc_port_pairs(**filter_dict_os
)
3123 sfi_list
= sfi_dict
["port_pairs"]
3124 self
.__sfi
_os
2mano
(sfi_list
)
3128 neExceptions
.ConnectionFailed
,
3129 ksExceptions
.ClientException
,
3130 neExceptions
.NeutronException
,
3133 self
._format
_exception
(e
)
3135 def delete_sfi(self
, sfi_id
):
3136 self
.logger
.debug("Deleting Service Function Instance '%s' from VIM", sfi_id
)
3139 self
._reload
_connection
()
3140 self
.neutron
.delete_sfc_port_pair(sfi_id
)
3144 neExceptions
.ConnectionFailed
,
3145 neExceptions
.NeutronException
,
3146 ksExceptions
.ClientException
,
3147 neExceptions
.NeutronException
,
3150 self
._format
_exception
(e
)
3152 def new_sf(self
, name
, sfis
, sfc_encap
=True):
3153 self
.logger
.debug("Adding a new Service Function to VIM, named '%s'", name
)
3157 self
._reload
_connection
()
3158 # correlation = None
3160 # correlation = "nsh"
3162 for instance
in sfis
:
3163 sfi
= self
.get_sfi(instance
)
3165 if sfi
.get("sfc_encap") != sfc_encap
:
3166 raise vimconn
.VimConnNotSupportedException(
3167 "OpenStack VIM connector requires all SFIs of the "
3168 "same SF to share the same SFC Encapsulation"
3171 sf_dict
= {"name": name
, "port_pairs": sfis
}
3172 new_sf
= self
.neutron
.create_sfc_port_pair_group(
3173 {"port_pair_group": sf_dict
}
3176 return new_sf
["port_pair_group"]["id"]
3178 neExceptions
.ConnectionFailed
,
3179 ksExceptions
.ClientException
,
3180 neExceptions
.NeutronException
,
3185 self
.neutron
.delete_sfc_port_pair_group(
3186 new_sf
["port_pair_group"]["id"]
3190 "Creation of Service Function failed, with "
3191 "subsequent deletion failure as well."
3194 self
._format
_exception
(e
)
3196 def get_sf(self
, sf_id
):
3197 self
.logger
.debug("Getting Service Function %s from VIM", sf_id
)
3198 filter_dict
= {"id": sf_id
}
3199 sf_list
= self
.get_sf_list(filter_dict
)
3201 if len(sf_list
) == 0:
3202 raise vimconn
.VimConnNotFoundException(
3203 "Service Function '{}' not found".format(sf_id
)
3205 elif len(sf_list
) > 1:
3206 raise vimconn
.VimConnConflictException(
3207 "Found more than one Service Function with this criteria"
3214 def get_sf_list(self
, filter_dict
={}):
3216 "Getting Service Function from VIM filter: '%s'", str(filter_dict
)
3220 self
._reload
_connection
()
3221 filter_dict_os
= filter_dict
.copy()
3223 if self
.api_version3
and "tenant_id" in filter_dict_os
:
3224 filter_dict_os
["project_id"] = filter_dict_os
.pop("tenant_id")
3226 sf_dict
= self
.neutron
.list_sfc_port_pair_groups(**filter_dict_os
)
3227 sf_list
= sf_dict
["port_pair_groups"]
3228 self
.__sf
_os
2mano
(sf_list
)
3232 neExceptions
.ConnectionFailed
,
3233 ksExceptions
.ClientException
,
3234 neExceptions
.NeutronException
,
3237 self
._format
_exception
(e
)
3239 def delete_sf(self
, sf_id
):
3240 self
.logger
.debug("Deleting Service Function '%s' from VIM", sf_id
)
3243 self
._reload
_connection
()
3244 self
.neutron
.delete_sfc_port_pair_group(sf_id
)
3248 neExceptions
.ConnectionFailed
,
3249 neExceptions
.NeutronException
,
3250 ksExceptions
.ClientException
,
3251 neExceptions
.NeutronException
,
3254 self
._format
_exception
(e
)
3256 def new_sfp(self
, name
, classifications
, sfs
, sfc_encap
=True, spi
=None):
3257 self
.logger
.debug("Adding a new Service Function Path to VIM, named '%s'", name
)
3261 self
._reload
_connection
()
3262 # In networking-sfc the MPLS encapsulation is legacy
3263 # should be used when no full SFC Encapsulation is intended
3264 correlation
= "mpls"
3271 "flow_classifiers": classifications
,
3272 "port_pair_groups": sfs
,
3273 "chain_parameters": {"correlation": correlation
},
3277 sfp_dict
["chain_id"] = spi
3279 new_sfp
= self
.neutron
.create_sfc_port_chain({"port_chain": sfp_dict
})
3281 return new_sfp
["port_chain"]["id"]
3283 neExceptions
.ConnectionFailed
,
3284 ksExceptions
.ClientException
,
3285 neExceptions
.NeutronException
,
3290 self
.neutron
.delete_sfc_port_chain(new_sfp
["port_chain"]["id"])
3293 "Creation of Service Function Path failed, with "
3294 "subsequent deletion failure as well."
3297 self
._format
_exception
(e
)
3299 def get_sfp(self
, sfp_id
):
3300 self
.logger
.debug(" Getting Service Function Path %s from VIM", sfp_id
)
3302 filter_dict
= {"id": sfp_id
}
3303 sfp_list
= self
.get_sfp_list(filter_dict
)
3305 if len(sfp_list
) == 0:
3306 raise vimconn
.VimConnNotFoundException(
3307 "Service Function Path '{}' not found".format(sfp_id
)
3309 elif len(sfp_list
) > 1:
3310 raise vimconn
.VimConnConflictException(
3311 "Found more than one Service Function Path with this criteria"
3318 def get_sfp_list(self
, filter_dict
={}):
3320 "Getting Service Function Paths from VIM filter: '%s'", str(filter_dict
)
3324 self
._reload
_connection
()
3325 filter_dict_os
= filter_dict
.copy()
3327 if self
.api_version3
and "tenant_id" in filter_dict_os
:
3328 filter_dict_os
["project_id"] = filter_dict_os
.pop("tenant_id")
3330 sfp_dict
= self
.neutron
.list_sfc_port_chains(**filter_dict_os
)
3331 sfp_list
= sfp_dict
["port_chains"]
3332 self
.__sfp
_os
2mano
(sfp_list
)
3336 neExceptions
.ConnectionFailed
,
3337 ksExceptions
.ClientException
,
3338 neExceptions
.NeutronException
,
3341 self
._format
_exception
(e
)
3343 def delete_sfp(self
, sfp_id
):
3344 self
.logger
.debug("Deleting Service Function Path '%s' from VIM", sfp_id
)
3347 self
._reload
_connection
()
3348 self
.neutron
.delete_sfc_port_chain(sfp_id
)
3352 neExceptions
.ConnectionFailed
,
3353 neExceptions
.NeutronException
,
3354 ksExceptions
.ClientException
,
3355 neExceptions
.NeutronException
,
3358 self
._format
_exception
(e
)
3360 def refresh_sfps_status(self
, sfp_list
):
3361 """Get the status of the service function path
3362 Params: the list of sfp identifiers
3363 Returns a dictionary with:
3364 vm_id: #VIM id of this service function path
3365 status: #Mandatory. Text with one of:
3366 # DELETED (not found at vim)
3367 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
3368 # OTHER (Vim reported other status not understood)
3369 # ERROR (VIM indicates an ERROR status)
3371 # CREATING (on building process)
3372 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
3373 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)F
3377 "refresh_sfps status: Getting tenant SFP information from VIM"
3380 for sfp_id
in sfp_list
:
3384 sfp_vim
= self
.get_sfp(sfp_id
)
3387 sfp
["status"] = vmStatus2manoFormat
["ACTIVE"]
3389 sfp
["status"] = "OTHER"
3390 sfp
["error_msg"] = "VIM status reported " + sfp
["status"]
3392 sfp
["vim_info"] = self
.serialize(sfp_vim
)
3394 if sfp_vim
.get("fault"):
3395 sfp
["error_msg"] = str(sfp_vim
["fault"])
3396 except vimconn
.VimConnNotFoundException
as e
:
3397 self
.logger
.error("Exception getting sfp status: %s", str(e
))
3398 sfp
["status"] = "DELETED"
3399 sfp
["error_msg"] = str(e
)
3400 except vimconn
.VimConnException
as e
:
3401 self
.logger
.error("Exception getting sfp status: %s", str(e
))
3402 sfp
["status"] = "VIM_ERROR"
3403 sfp
["error_msg"] = str(e
)
3405 sfp_dict
[sfp_id
] = sfp
3409 def refresh_sfis_status(self
, sfi_list
):
3410 """Get the status of the service function instances
3411 Params: the list of sfi identifiers
3412 Returns a dictionary with:
3413 vm_id: #VIM id of this service function instance
3414 status: #Mandatory. Text with one of:
3415 # DELETED (not found at vim)
3416 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
3417 # OTHER (Vim reported other status not understood)
3418 # ERROR (VIM indicates an ERROR status)
3420 # CREATING (on building process)
3421 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
3422 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
3426 "refresh_sfis status: Getting tenant sfi information from VIM"
3429 for sfi_id
in sfi_list
:
3433 sfi_vim
= self
.get_sfi(sfi_id
)
3436 sfi
["status"] = vmStatus2manoFormat
["ACTIVE"]
3438 sfi
["status"] = "OTHER"
3439 sfi
["error_msg"] = "VIM status reported " + sfi
["status"]
3441 sfi
["vim_info"] = self
.serialize(sfi_vim
)
3443 if sfi_vim
.get("fault"):
3444 sfi
["error_msg"] = str(sfi_vim
["fault"])
3445 except vimconn
.VimConnNotFoundException
as e
:
3446 self
.logger
.error("Exception getting sfi status: %s", str(e
))
3447 sfi
["status"] = "DELETED"
3448 sfi
["error_msg"] = str(e
)
3449 except vimconn
.VimConnException
as e
:
3450 self
.logger
.error("Exception getting sfi status: %s", str(e
))
3451 sfi
["status"] = "VIM_ERROR"
3452 sfi
["error_msg"] = str(e
)
3454 sfi_dict
[sfi_id
] = sfi
3458 def refresh_sfs_status(self
, sf_list
):
3459 """Get the status of the service functions
3460 Params: the list of sf identifiers
3461 Returns a dictionary with:
3462 vm_id: #VIM id of this service function
3463 status: #Mandatory. Text with one of:
3464 # DELETED (not found at vim)
3465 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
3466 # OTHER (Vim reported other status not understood)
3467 # ERROR (VIM indicates an ERROR status)
3469 # CREATING (on building process)
3470 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
3471 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
3474 self
.logger
.debug("refresh_sfs status: Getting tenant sf information from VIM")
3476 for sf_id
in sf_list
:
3480 sf_vim
= self
.get_sf(sf_id
)
3483 sf
["status"] = vmStatus2manoFormat
["ACTIVE"]
3485 sf
["status"] = "OTHER"
3486 sf
["error_msg"] = "VIM status reported " + sf_vim
["status"]
3488 sf
["vim_info"] = self
.serialize(sf_vim
)
3490 if sf_vim
.get("fault"):
3491 sf
["error_msg"] = str(sf_vim
["fault"])
3492 except vimconn
.VimConnNotFoundException
as e
:
3493 self
.logger
.error("Exception getting sf status: %s", str(e
))
3494 sf
["status"] = "DELETED"
3495 sf
["error_msg"] = str(e
)
3496 except vimconn
.VimConnException
as e
:
3497 self
.logger
.error("Exception getting sf status: %s", str(e
))
3498 sf
["status"] = "VIM_ERROR"
3499 sf
["error_msg"] = str(e
)
3505 def refresh_classifications_status(self
, classification_list
):
3506 """Get the status of the classifications
3507 Params: the list of classification identifiers
3508 Returns a dictionary with:
3509 vm_id: #VIM id of this classifier
3510 status: #Mandatory. Text with one of:
3511 # DELETED (not found at vim)
3512 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
3513 # OTHER (Vim reported other status not understood)
3514 # ERROR (VIM indicates an ERROR status)
3516 # CREATING (on building process)
3517 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
3518 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
3520 classification_dict
= {}
3522 "refresh_classifications status: Getting tenant classification information from VIM"
3525 for classification_id
in classification_list
:
3529 classification_vim
= self
.get_classification(classification_id
)
3531 if classification_vim
:
3532 classification
["status"] = vmStatus2manoFormat
["ACTIVE"]
3534 classification
["status"] = "OTHER"
3535 classification
["error_msg"] = (
3536 "VIM status reported " + classification
["status"]
3539 classification
["vim_info"] = self
.serialize(classification_vim
)
3541 if classification_vim
.get("fault"):
3542 classification
["error_msg"] = str(classification_vim
["fault"])
3543 except vimconn
.VimConnNotFoundException
as e
:
3544 self
.logger
.error("Exception getting classification status: %s", str(e
))
3545 classification
["status"] = "DELETED"
3546 classification
["error_msg"] = str(e
)
3547 except vimconn
.VimConnException
as e
:
3548 self
.logger
.error("Exception getting classification status: %s", str(e
))
3549 classification
["status"] = "VIM_ERROR"
3550 classification
["error_msg"] = str(e
)
3552 classification_dict
[classification_id
] = classification
3554 return classification_dict
3556 def new_affinity_group(self
, affinity_group_data
):
3557 """Adds a server group to VIM
3558 affinity_group_data contains a dictionary with information, keys:
3559 name: name in VIM for the server group
3560 type: affinity or anti-affinity
3561 scope: Only nfvi-node allowed
3562 Returns the server group identifier"""
3563 self
.logger
.debug("Adding Server Group '%s'", str(affinity_group_data
))
3566 name
= affinity_group_data
["name"]
3567 policy
= affinity_group_data
["type"]
3569 self
._reload
_connection
()
3570 new_server_group
= self
.nova
.server_groups
.create(name
, policy
)
3572 return new_server_group
.id
3574 ksExceptions
.ClientException
,
3575 nvExceptions
.ClientException
,
3579 self
._format
_exception
(e
)
3581 def get_affinity_group(self
, affinity_group_id
):
3582 """Obtain server group details from the VIM. Returns the server group detais as a dict"""
3583 self
.logger
.debug("Getting flavor '%s'", affinity_group_id
)
3585 self
._reload
_connection
()
3586 server_group
= self
.nova
.server_groups
.find(id=affinity_group_id
)
3588 return server_group
.to_dict()
3590 nvExceptions
.NotFound
,
3591 nvExceptions
.ClientException
,
3592 ksExceptions
.ClientException
,
3595 self
._format
_exception
(e
)
3597 def delete_affinity_group(self
, affinity_group_id
):
3598 """Deletes a server group from the VIM. Returns the old affinity_group_id"""
3599 self
.logger
.debug("Getting server group '%s'", affinity_group_id
)
3601 self
._reload
_connection
()
3602 self
.nova
.server_groups
.delete(affinity_group_id
)
3604 return affinity_group_id
3606 nvExceptions
.NotFound
,
3607 ksExceptions
.ClientException
,
3608 nvExceptions
.ClientException
,
3611 self
._format
_exception
(e
)
3613 def get_vdu_state(self
, vm_id
):
3615 Getting the state of a vdu
3617 vm_id: ID of an instance
3619 self
.logger
.debug("Getting the status of VM")
3620 self
.logger
.debug("VIM VM ID %s", vm_id
)
3621 self
._reload
_connection
()
3622 server
= self
.nova
.servers
.find(id=vm_id
)
3623 server_dict
= server
.to_dict()
3625 server_dict
["status"],
3626 server_dict
["flavor"]["id"],
3627 server_dict
["OS-EXT-SRV-ATTR:host"],
3628 server_dict
["OS-EXT-AZ:availability_zone"],
3630 self
.logger
.debug("vdu_data %s", vdu_data
)
3633 def check_compute_availability(self
, host
, server_flavor_details
):
3634 self
._reload
_connection
()
3635 hypervisor_search
= self
.nova
.hypervisors
.search(
3636 hypervisor_match
=host
, servers
=True
3638 for hypervisor
in hypervisor_search
:
3639 hypervisor_id
= hypervisor
.to_dict()["id"]
3640 hypervisor_details
= self
.nova
.hypervisors
.get(hypervisor
=hypervisor_id
)
3641 hypervisor_dict
= hypervisor_details
.to_dict()
3642 hypervisor_temp
= json
.dumps(hypervisor_dict
)
3643 hypervisor_json
= json
.loads(hypervisor_temp
)
3644 resources_available
= [
3645 hypervisor_json
["free_ram_mb"],
3646 hypervisor_json
["disk_available_least"],
3647 hypervisor_json
["vcpus"] - hypervisor_json
["vcpus_used"],
3649 compute_available
= all(
3650 x
> y
for x
, y
in zip(resources_available
, server_flavor_details
)
3652 if compute_available
:
3655 def check_availability_zone(
3656 self
, old_az
, server_flavor_details
, old_host
, host
=None
3658 self
._reload
_connection
()
3659 az_check
= {"zone_check": False, "compute_availability": None}
3660 aggregates_list
= self
.nova
.aggregates
.list()
3661 for aggregate
in aggregates_list
:
3662 aggregate_details
= aggregate
.to_dict()
3663 aggregate_temp
= json
.dumps(aggregate_details
)
3664 aggregate_json
= json
.loads(aggregate_temp
)
3665 if aggregate_json
["availability_zone"] == old_az
:
3666 hosts_list
= aggregate_json
["hosts"]
3667 if host
is not None:
3668 if host
in hosts_list
:
3669 az_check
["zone_check"] = True
3670 available_compute_id
= self
.check_compute_availability(
3671 host
, server_flavor_details
3673 if available_compute_id
is not None:
3674 az_check
["compute_availability"] = available_compute_id
3676 for check_host
in hosts_list
:
3677 if check_host
!= old_host
:
3678 available_compute_id
= self
.check_compute_availability(
3679 check_host
, server_flavor_details
3681 if available_compute_id
is not None:
3682 az_check
["zone_check"] = True
3683 az_check
["compute_availability"] = available_compute_id
3686 az_check
["zone_check"] = True
3689 def migrate_instance(self
, vm_id
, compute_host
=None):
3693 vm_id: ID of an instance
3694 compute_host: Host to migrate the vdu to
3696 self
._reload
_connection
()
3698 instance_state
= self
.get_vdu_state(vm_id
)
3699 server_flavor_id
= instance_state
[1]
3700 server_hypervisor_name
= instance_state
[2]
3701 server_availability_zone
= instance_state
[3]
3703 server_flavor
= self
.nova
.flavors
.find(id=server_flavor_id
).to_dict()
3704 server_flavor_details
= [
3705 server_flavor
["ram"],
3706 server_flavor
["disk"],
3707 server_flavor
["vcpus"],
3709 if compute_host
== server_hypervisor_name
:
3710 raise vimconn
.VimConnException(
3711 "Unable to migrate instance '{}' to the same host '{}'".format(
3714 http_code
=vimconn
.HTTP_Bad_Request
,
3716 az_status
= self
.check_availability_zone(
3717 server_availability_zone
,
3718 server_flavor_details
,
3719 server_hypervisor_name
,
3722 availability_zone_check
= az_status
["zone_check"]
3723 available_compute_id
= az_status
.get("compute_availability")
3725 if availability_zone_check
is False:
3726 raise vimconn
.VimConnException(
3727 "Unable to migrate instance '{}' to a different availability zone".format(
3730 http_code
=vimconn
.HTTP_Bad_Request
,
3732 if available_compute_id
is not None:
3733 self
.nova
.servers
.live_migrate(
3735 host
=available_compute_id
,
3736 block_migration
=True,
3737 disk_over_commit
=False,
3740 changed_compute_host
= ""
3741 if state
== "MIGRATING":
3742 vm_state
= self
.__wait
_for
_vm
(vm_id
, "ACTIVE")
3743 changed_compute_host
= self
.get_vdu_state(vm_id
)[2]
3744 if vm_state
and changed_compute_host
== available_compute_id
:
3746 "Instance '{}' migrated to the new compute host '{}'".format(
3747 vm_id
, changed_compute_host
3750 return state
, available_compute_id
3752 raise vimconn
.VimConnException(
3753 "Migration Failed. Instance '{}' not moved to the new host {}".format(
3754 vm_id
, available_compute_id
3756 http_code
=vimconn
.HTTP_Bad_Request
,
3759 raise vimconn
.VimConnException(
3760 "Compute '{}' not available or does not have enough resources to migrate the instance".format(
3761 available_compute_id
3763 http_code
=vimconn
.HTTP_Bad_Request
,
3766 nvExceptions
.BadRequest
,
3767 nvExceptions
.ClientException
,
3768 nvExceptions
.NotFound
,
3770 self
._format
_exception
(e
)
3772 def resize_instance(self
, vm_id
, new_flavor_id
):
3774 For resizing the vm based on the given
3777 vm_id : ID of an instance
3778 new_flavor_id : Flavor id to be resized
3779 Return the status of a resized instance
3781 self
._reload
_connection
()
3782 self
.logger
.debug("resize the flavor of an instance")
3783 instance_status
, old_flavor_id
, compute_host
, az
= self
.get_vdu_state(vm_id
)
3784 old_flavor_disk
= self
.nova
.flavors
.find(id=old_flavor_id
).to_dict()["disk"]
3785 new_flavor_disk
= self
.nova
.flavors
.find(id=new_flavor_id
).to_dict()["disk"]
3787 if instance_status
== "ACTIVE" or instance_status
== "SHUTOFF":
3788 if old_flavor_disk
> new_flavor_disk
:
3789 raise nvExceptions
.BadRequest(
3791 message
="Server disk resize failed. Resize to lower disk flavor is not allowed",
3794 self
.nova
.servers
.resize(server
=vm_id
, flavor
=new_flavor_id
)
3795 vm_state
= self
.__wait
_for
_vm
(vm_id
, "VERIFY_RESIZE")
3797 instance_resized_status
= self
.confirm_resize(vm_id
)
3798 return instance_resized_status
3800 raise nvExceptions
.BadRequest(
3802 message
="Cannot 'resize' vm_state is in ERROR",
3806 self
.logger
.debug("ERROR : Instance is not in ACTIVE or SHUTOFF state")
3807 raise nvExceptions
.BadRequest(
3809 message
="Cannot 'resize' instance while it is in vm_state resized",
3812 nvExceptions
.BadRequest
,
3813 nvExceptions
.ClientException
,
3814 nvExceptions
.NotFound
,
3816 self
._format
_exception
(e
)
3818 def confirm_resize(self
, vm_id
):
3820 Confirm the resize of an instance
3822 vm_id: ID of an instance
3824 self
._reload
_connection
()
3825 self
.nova
.servers
.confirm_resize(server
=vm_id
)
3826 if self
.get_vdu_state(vm_id
)[0] == "VERIFY_RESIZE":
3827 self
.__wait
_for
_vm
(vm_id
, "ACTIVE")
3828 instance_status
= self
.get_vdu_state(vm_id
)[0]
3829 return instance_status