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"),
1374 new_flavor
= self
.nova
.flavors
.create(
1378 disk
=flavor_data
.get("disk", 0),
1379 ephemeral
=flavor_data
.get("ephemeral", 0),
1380 swap
=flavor_data
.get("swap", 0),
1381 is_public
=flavor_data
.get("is_public", True),
1385 new_flavor
.set_keys(extra_specs
)
1387 return new_flavor
.id
1388 except nvExceptions
.Conflict
as e
:
1389 if change_name_if_used
and retry
< max_retries
:
1392 self
._format
_exception
(e
)
1393 # except nvExceptions.BadRequest as e:
1395 ksExceptions
.ClientException
,
1396 nvExceptions
.ClientException
,
1400 self
._format
_exception
(e
)
1402 def delete_flavor(self
, flavor_id
):
1403 """Deletes a tenant flavor from openstack VIM. Returns the old flavor_id"""
1405 self
._reload
_connection
()
1406 self
.nova
.flavors
.delete(flavor_id
)
1409 # except nvExceptions.BadRequest as e:
1411 nvExceptions
.NotFound
,
1412 ksExceptions
.ClientException
,
1413 nvExceptions
.ClientException
,
1416 self
._format
_exception
(e
)
1418 def new_image(self
, image_dict
):
1420 Adds a tenant image to VIM. imge_dict is a dictionary with:
1422 disk_format: qcow2, vhd, vmdk, raw (by default), ...
1423 location: path or URI
1424 public: "yes" or "no"
1425 metadata: metadata of the image
1426 Returns the image_id
1431 while retry
< max_retries
:
1434 self
._reload
_connection
()
1436 # determine format http://docs.openstack.org/developer/glance/formats.html
1437 if "disk_format" in image_dict
:
1438 disk_format
= image_dict
["disk_format"]
1439 else: # autodiscover based on extension
1440 if image_dict
["location"].endswith(".qcow2"):
1441 disk_format
= "qcow2"
1442 elif image_dict
["location"].endswith(".vhd"):
1444 elif image_dict
["location"].endswith(".vmdk"):
1445 disk_format
= "vmdk"
1446 elif image_dict
["location"].endswith(".vdi"):
1448 elif image_dict
["location"].endswith(".iso"):
1450 elif image_dict
["location"].endswith(".aki"):
1452 elif image_dict
["location"].endswith(".ari"):
1454 elif image_dict
["location"].endswith(".ami"):
1460 "new_image: '%s' loading from '%s'",
1462 image_dict
["location"],
1464 if self
.vim_type
== "VIO":
1465 container_format
= "bare"
1466 if "container_format" in image_dict
:
1467 container_format
= image_dict
["container_format"]
1469 new_image
= self
.glance
.images
.create(
1470 name
=image_dict
["name"],
1471 container_format
=container_format
,
1472 disk_format
=disk_format
,
1475 new_image
= self
.glance
.images
.create(name
=image_dict
["name"])
1477 if image_dict
["location"].startswith("http"):
1478 # TODO there is not a method to direct download. It must be downloaded locally with requests
1479 raise vimconn
.VimConnNotImplemented("Cannot create image from URL")
1481 with
open(image_dict
["location"]) as fimage
:
1482 self
.glance
.images
.upload(new_image
.id, fimage
)
1483 # new_image = self.glancev1.images.create(name=image_dict["name"], is_public=
1484 # image_dict.get("public","yes")=="yes",
1485 # container_format="bare", data=fimage, disk_format=disk_format)
1487 metadata_to_load
= image_dict
.get("metadata")
1489 # TODO location is a reserved word for current openstack versions. fixed for VIO please check
1491 if self
.vim_type
== "VIO":
1492 metadata_to_load
["upload_location"] = image_dict
["location"]
1494 metadata_to_load
["location"] = image_dict
["location"]
1496 self
.glance
.images
.update(new_image
.id, **metadata_to_load
)
1500 nvExceptions
.Conflict
,
1501 ksExceptions
.ClientException
,
1502 nvExceptions
.ClientException
,
1504 self
._format
_exception
(e
)
1507 gl1Exceptions
.HTTPException
,
1508 gl1Exceptions
.CommunicationError
,
1511 if retry
== max_retries
:
1514 self
._format
_exception
(e
)
1515 except IOError as e
: # can not open the file
1516 raise vimconn
.VimConnConnectionException(
1517 "{}: {} for {}".format(type(e
).__name
__, e
, image_dict
["location"]),
1518 http_code
=vimconn
.HTTP_Bad_Request
,
1521 def delete_image(self
, image_id
):
1522 """Deletes a tenant image from openstack VIM. Returns the old id"""
1524 self
._reload
_connection
()
1525 self
.glance
.images
.delete(image_id
)
1529 nvExceptions
.NotFound
,
1530 ksExceptions
.ClientException
,
1531 nvExceptions
.ClientException
,
1532 gl1Exceptions
.CommunicationError
,
1533 gl1Exceptions
.HTTPNotFound
,
1535 ) as e
: # TODO remove
1536 self
._format
_exception
(e
)
1538 def get_image_id_from_path(self
, path
):
1539 """Get the image id from image path in the VIM database. Returns the image_id"""
1541 self
._reload
_connection
()
1542 images
= self
.glance
.images
.list()
1544 for image
in images
:
1545 if image
.metadata
.get("location") == path
:
1548 raise vimconn
.VimConnNotFoundException(
1549 "image with location '{}' not found".format(path
)
1552 ksExceptions
.ClientException
,
1553 nvExceptions
.ClientException
,
1554 gl1Exceptions
.CommunicationError
,
1557 self
._format
_exception
(e
)
1559 def get_image_list(self
, filter_dict
={}):
1560 """Obtain tenant images from VIM
1564 checksum: image checksum
1565 Returns the image list of dictionaries:
1566 [{<the fields at Filter_dict plus some VIM specific>}, ...]
1569 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
1572 self
._reload
_connection
()
1573 # filter_dict_os = filter_dict.copy()
1574 # First we filter by the available filter fields: name, id. The others are removed.
1575 image_list
= self
.glance
.images
.list()
1578 for image
in image_list
:
1580 if filter_dict
.get("name") and image
["name"] != filter_dict
["name"]:
1583 if filter_dict
.get("id") and image
["id"] != filter_dict
["id"]:
1587 filter_dict
.get("checksum")
1588 and image
["checksum"] != filter_dict
["checksum"]
1592 filtered_list
.append(image
.copy())
1593 except gl1Exceptions
.HTTPNotFound
:
1596 return filtered_list
1598 ksExceptions
.ClientException
,
1599 nvExceptions
.ClientException
,
1600 gl1Exceptions
.CommunicationError
,
1603 self
._format
_exception
(e
)
1605 def __wait_for_vm(self
, vm_id
, status
):
1606 """wait until vm is in the desired status and return True.
1607 If the VM gets in ERROR status, return false.
1608 If the timeout is reached generate an exception"""
1610 while elapsed_time
< server_timeout
:
1611 vm_status
= self
.nova
.servers
.get(vm_id
).status
1613 if vm_status
== status
:
1616 if vm_status
== "ERROR":
1622 # if we exceeded the timeout rollback
1623 if elapsed_time
>= server_timeout
:
1624 raise vimconn
.VimConnException(
1625 "Timeout waiting for instance " + vm_id
+ " to get " + status
,
1626 http_code
=vimconn
.HTTP_Request_Timeout
,
1629 def _get_openstack_availablity_zones(self
):
1631 Get from openstack availability zones available
1635 openstack_availability_zone
= self
.nova
.availability_zones
.list()
1636 openstack_availability_zone
= [
1638 for zone
in openstack_availability_zone
1639 if zone
.zoneName
!= "internal"
1642 return openstack_availability_zone
1646 def _set_availablity_zones(self
):
1648 Set vim availablity zone
1651 if "availability_zone" in self
.config
:
1652 vim_availability_zones
= self
.config
.get("availability_zone")
1654 if isinstance(vim_availability_zones
, str):
1655 self
.availability_zone
= [vim_availability_zones
]
1656 elif isinstance(vim_availability_zones
, list):
1657 self
.availability_zone
= vim_availability_zones
1659 self
.availability_zone
= self
._get
_openstack
_availablity
_zones
()
1661 def _get_vm_availability_zone(
1662 self
, availability_zone_index
, availability_zone_list
1665 Return thge availability zone to be used by the created VM.
1666 :return: The VIM availability zone to be used or None
1668 if availability_zone_index
is None:
1669 if not self
.config
.get("availability_zone"):
1671 elif isinstance(self
.config
.get("availability_zone"), str):
1672 return self
.config
["availability_zone"]
1674 # TODO consider using a different parameter at config for default AV and AV list match
1675 return self
.config
["availability_zone"][0]
1677 vim_availability_zones
= self
.availability_zone
1678 # check if VIM offer enough availability zones describe in the VNFD
1679 if vim_availability_zones
and len(availability_zone_list
) <= len(
1680 vim_availability_zones
1682 # check if all the names of NFV AV match VIM AV names
1683 match_by_index
= False
1684 for av
in availability_zone_list
:
1685 if av
not in vim_availability_zones
:
1686 match_by_index
= True
1690 return vim_availability_zones
[availability_zone_index
]
1692 return availability_zone_list
[availability_zone_index
]
1694 raise vimconn
.VimConnConflictException(
1695 "No enough availability zones at VIM for this deployment"
1705 affinity_group_list
,
1709 availability_zone_index
=None,
1710 availability_zone_list
=None,
1712 """Adds a VM instance to VIM
1714 start: indicates if VM must start or boot in pause mode. Ignored
1715 image_id,flavor_id: image and flavor uuid
1716 affinity_group_list: list of affinity groups, each one is a dictionary.
1718 net_list: list of interfaces, each one is a dictionary with:
1720 net_id: network uuid to connect
1721 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
1722 model: interface model, ignored #TODO
1723 mac_address: used for SR-IOV ifaces #TODO for other types
1724 use: 'data', 'bridge', 'mgmt'
1725 type: 'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
1726 vim_id: filled/added by this function
1727 floating_ip: True/False (or it can be None)
1728 port_security: True/False
1729 'cloud_config': (optional) dictionary with:
1730 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
1731 'users': (optional) list of users to be inserted, each item is a dict with:
1732 'name': (mandatory) user name,
1733 'key-pairs': (optional) list of strings with the public key to be inserted to the user
1734 'user-data': (optional) string is a text script to be passed directly to cloud-init
1735 'config-files': (optional). List of files to be transferred. Each item is a dict with:
1736 'dest': (mandatory) string with the destination absolute path
1737 'encoding': (optional, by default text). Can be one of:
1738 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
1739 'content' (mandatory): string with the content of the file
1740 'permissions': (optional) string with file permissions, typically octal notation '0644'
1741 'owner': (optional) file owner, string with the format 'owner:group'
1742 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
1743 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
1744 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
1745 'size': (mandatory) string with the size of the disk in GB
1746 'vim_id' (optional) should use this existing volume id
1747 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
1748 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
1749 availability_zone_index is None
1750 #TODO ip, security groups
1751 Returns a tuple with the instance identifier and created_items or raises an exception on error
1752 created_items can be None or a dictionary where this method can include key-values that will be passed to
1753 the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
1754 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
1758 "new_vminstance input: image='%s' flavor='%s' nics='%s'",
1769 external_network
= []
1770 # ^list of external networks to be connected to instance, later on used to create floating_ip
1771 no_secured_ports
= [] # List of port-is with port-security disabled
1772 self
._reload
_connection
()
1773 # metadata_vpci = {} # For a specific neutron plugin
1774 block_device_mapping
= None
1776 for net
in net_list
:
1777 if not net
.get("net_id"): # skip non connected iface
1781 "network_id": net
["net_id"],
1782 "name": net
.get("name"),
1783 "admin_state_up": True,
1787 self
.config
.get("security_groups")
1788 and net
.get("port_security") is not False
1789 and not self
.config
.get("no_port_security_extension")
1791 if not self
.security_groups_id
:
1792 self
._get
_ids
_from
_name
()
1794 port_dict
["security_groups"] = self
.security_groups_id
1796 if net
["type"] == "virtual":
1799 # metadata_vpci[ net["net_id"] ] = [[ net["vpci"], "" ]]
1800 elif net
["type"] == "VF" or net
["type"] == "SR-IOV": # for VF
1802 # if "VF" not in metadata_vpci:
1803 # metadata_vpci["VF"]=[]
1804 # metadata_vpci["VF"].append([ net["vpci"], "" ])
1805 port_dict
["binding:vnic_type"] = "direct"
1807 # VIO specific Changes
1808 if self
.vim_type
== "VIO":
1809 # Need to create port with port_security_enabled = False and no-security-groups
1810 port_dict
["port_security_enabled"] = False
1811 port_dict
["provider_security_groups"] = []
1812 port_dict
["security_groups"] = []
1813 else: # For PT PCI-PASSTHROUGH
1815 # if "PF" not in metadata_vpci:
1816 # metadata_vpci["PF"]=[]
1817 # metadata_vpci["PF"].append([ net["vpci"], "" ])
1818 port_dict
["binding:vnic_type"] = "direct-physical"
1820 if not port_dict
["name"]:
1821 port_dict
["name"] = name
1823 if net
.get("mac_address"):
1824 port_dict
["mac_address"] = net
["mac_address"]
1826 if net
.get("ip_address"):
1827 port_dict
["fixed_ips"] = [{"ip_address": net
["ip_address"]}]
1828 # TODO add "subnet_id": <subnet_id>
1830 new_port
= self
.neutron
.create_port({"port": port_dict
})
1831 created_items
["port:" + str(new_port
["port"]["id"])] = True
1832 net
["mac_adress"] = new_port
["port"]["mac_address"]
1833 net
["vim_id"] = new_port
["port"]["id"]
1834 # if try to use a network without subnetwork, it will return a emtpy list
1835 fixed_ips
= new_port
["port"].get("fixed_ips")
1838 net
["ip"] = fixed_ips
[0].get("ip_address")
1842 port
= {"port-id": new_port
["port"]["id"]}
1843 if float(self
.nova
.api_version
.get_string()) >= 2.32:
1844 port
["tag"] = new_port
["port"]["name"]
1846 net_list_vim
.append(port
)
1848 if net
.get("floating_ip", False):
1849 net
["exit_on_floating_ip_error"] = True
1850 external_network
.append(net
)
1851 elif net
["use"] == "mgmt" and self
.config
.get("use_floating_ip"):
1852 net
["exit_on_floating_ip_error"] = False
1853 external_network
.append(net
)
1854 net
["floating_ip"] = self
.config
.get("use_floating_ip")
1856 # If port security is disabled when the port has not yet been attached to the VM, then all vm traffic
1858 # As a workaround we wait until the VM is active and then disable the port-security
1859 if net
.get("port_security") is False and not self
.config
.get(
1860 "no_port_security_extension"
1862 no_secured_ports
.append(
1864 new_port
["port"]["id"],
1865 net
.get("port_security_disable_strategy"),
1870 # metadata = {"pci_assignement": json.dumps(metadata_vpci)}
1871 # if len(metadata["pci_assignement"]) >255:
1872 # #limit the metadata size
1873 # #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
1874 # self.logger.warn("Metadata deleted since it exceeds the expected length (255) ")
1878 "name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s'",
1887 config_drive
, userdata
= self
._create
_user
_data
(cloud_config
)
1889 # get availability Zone
1890 vm_av_zone
= self
._get
_vm
_availability
_zone
(
1891 availability_zone_index
, availability_zone_list
1894 # Create additional volumes in case these are present in disk_list
1895 existing_vim_volumes
= []
1896 base_disk_index
= ord("b")
1897 boot_volume_id
= None
1899 block_device_mapping
= {}
1900 for disk
in disk_list
:
1901 if disk
.get("vim_id"):
1902 block_device_mapping
["_vd" + chr(base_disk_index
)] = disk
[
1905 existing_vim_volumes
.append({"id": disk
["vim_id"]})
1907 if "image_id" in disk
:
1908 base_disk_index
= ord("a")
1909 volume
= self
.cinder
.volumes
.create(
1911 name
=name
+ "_vd" + chr(base_disk_index
),
1912 imageRef
=disk
["image_id"],
1913 # Make sure volume is in the same AZ as the VM to be attached to
1914 availability_zone
=vm_av_zone
,
1916 boot_volume_id
= volume
.id
1918 volume
= self
.cinder
.volumes
.create(
1920 name
=name
+ "_vd" + chr(base_disk_index
),
1921 # Make sure volume is in the same AZ as the VM to be attached to
1922 availability_zone
=vm_av_zone
,
1925 created_items
["volume:" + str(volume
.id)] = True
1926 block_device_mapping
["_vd" + chr(base_disk_index
)] = volume
.id
1928 base_disk_index
+= 1
1930 # Wait until created volumes are with status available
1932 while elapsed_time
< volume_timeout
:
1933 for created_item
in created_items
:
1934 v
, _
, volume_id
= created_item
.partition(":")
1936 if self
.cinder
.volumes
.get(volume_id
).status
!= "available":
1938 else: # all ready: break from while
1944 # Wait until existing volumes in vim are with status available
1945 while elapsed_time
< volume_timeout
:
1946 for volume
in existing_vim_volumes
:
1947 if self
.cinder
.volumes
.get(volume
["id"]).status
!= "available":
1949 else: # all ready: break from while
1955 # If we exceeded the timeout rollback
1956 if elapsed_time
>= volume_timeout
:
1957 raise vimconn
.VimConnException(
1958 "Timeout creating volumes for instance " + name
,
1959 http_code
=vimconn
.HTTP_Request_Timeout
,
1962 self
.cinder
.volumes
.set_bootable(boot_volume_id
, True)
1964 # Manage affinity groups/server groups
1965 server_group_id
= None
1966 scheduller_hints
= {}
1968 if affinity_group_list
:
1969 # Only first id on the list will be used. Openstack restriction
1970 server_group_id
= affinity_group_list
[0]["affinity_group_id"]
1971 scheduller_hints
["group"] = server_group_id
1974 "nova.servers.create({}, {}, {}, nics={}, security_groups={}, "
1975 "availability_zone={}, key_name={}, userdata={}, config_drive={}, "
1976 "block_device_mapping={}, server_group={})".format(
1981 self
.config
.get("security_groups"),
1983 self
.config
.get("keypair"),
1986 block_device_mapping
,
1990 server
= self
.nova
.servers
.create(
1995 security_groups
=self
.config
.get("security_groups"),
1996 # TODO remove security_groups in future versions. Already at neutron port
1997 availability_zone
=vm_av_zone
,
1998 key_name
=self
.config
.get("keypair"),
2000 config_drive
=config_drive
,
2001 block_device_mapping
=block_device_mapping
,
2002 scheduler_hints
=scheduller_hints
,
2003 ) # , description=description)
2005 vm_start_time
= time
.time()
2006 # Previously mentioned workaround to wait until the VM is active and then disable the port-security
2007 if no_secured_ports
:
2008 self
.__wait
_for
_vm
(server
.id, "ACTIVE")
2010 for port
in no_secured_ports
:
2012 "port": {"port_security_enabled": False, "security_groups": None}
2015 if port
[1] == "allow-address-pairs":
2017 "port": {"allowed_address_pairs": [{"ip_address": "0.0.0.0/0"}]}
2021 self
.neutron
.update_port(port
[0], port_update
)
2023 raise vimconn
.VimConnException(
2024 "It was not possible to disable port security for port {}".format(
2029 # print "DONE :-)", server
2032 for floating_network
in external_network
:
2035 floating_ip_retries
= 3
2036 # In case of RO in HA there can be conflicts, two RO trying to assign same floating IP, so retry
2039 floating_ips
= self
.neutron
.list_floatingips().get(
2042 random
.shuffle(floating_ips
) # randomize
2043 for fip
in floating_ips
:
2046 or fip
.get("tenant_id") != server
.tenant_id
2050 if isinstance(floating_network
["floating_ip"], str):
2052 fip
.get("floating_network_id")
2053 != floating_network
["floating_ip"]
2057 free_floating_ip
= fip
["id"]
2061 isinstance(floating_network
["floating_ip"], str)
2062 and floating_network
["floating_ip"].lower() != "true"
2064 pool_id
= floating_network
["floating_ip"]
2066 # Find the external network
2067 external_nets
= list()
2069 for net
in self
.neutron
.list_networks()["networks"]:
2070 if net
["router:external"]:
2071 external_nets
.append(net
)
2073 if len(external_nets
) == 0:
2074 raise vimconn
.VimConnException(
2075 "Cannot create floating_ip automatically since "
2076 "no external network is present",
2077 http_code
=vimconn
.HTTP_Conflict
,
2080 if len(external_nets
) > 1:
2081 raise vimconn
.VimConnException(
2082 "Cannot create floating_ip automatically since "
2083 "multiple external networks are present",
2084 http_code
=vimconn
.HTTP_Conflict
,
2087 pool_id
= external_nets
[0].get("id")
2091 "floating_network_id": pool_id
,
2092 "tenant_id": server
.tenant_id
,
2097 # self.logger.debug("Creating floating IP")
2098 new_floating_ip
= self
.neutron
.create_floatingip(param
)
2099 free_floating_ip
= new_floating_ip
["floatingip"]["id"]
2101 "floating_ip:" + str(free_floating_ip
)
2103 except Exception as e
:
2104 raise vimconn
.VimConnException(
2106 + ": Cannot create new floating_ip "
2108 http_code
=vimconn
.HTTP_Conflict
,
2112 # for race condition ensure not already assigned
2113 fip
= self
.neutron
.show_floatingip(free_floating_ip
)
2115 if fip
["floatingip"]["port_id"]:
2118 # the vim_id key contains the neutron.port_id
2119 self
.neutron
.update_floatingip(
2121 {"floatingip": {"port_id": floating_network
["vim_id"]}},
2123 # for race condition ensure not re-assigned to other VM after 5 seconds
2125 fip
= self
.neutron
.show_floatingip(free_floating_ip
)
2128 fip
["floatingip"]["port_id"]
2129 != floating_network
["vim_id"]
2132 "floating_ip {} re-assigned to other port".format(
2139 "Assigned floating_ip {} to VM {}".format(
2140 free_floating_ip
, server
.id
2144 except Exception as e
:
2145 # openstack need some time after VM creation to assign an IP. So retry if fails
2146 vm_status
= self
.nova
.servers
.get(server
.id).status
2148 if vm_status
not in ("ACTIVE", "ERROR"):
2149 if time
.time() - vm_start_time
< server_timeout
:
2152 elif floating_ip_retries
> 0:
2153 floating_ip_retries
-= 1
2156 raise vimconn
.VimConnException(
2157 "Cannot create floating_ip: {} {}".format(
2160 http_code
=vimconn
.HTTP_Conflict
,
2163 except Exception as e
:
2164 if not floating_network
["exit_on_floating_ip_error"]:
2165 self
.logger
.error("Cannot create floating_ip. %s", str(e
))
2170 return server
.id, created_items
2171 # except nvExceptions.NotFound as e:
2172 # error_value=-vimconn.HTTP_Not_Found
2173 # error_text= "vm instance %s not found" % vm_id
2174 # except TypeError as e:
2175 # raise vimconn.VimConnException(type(e).__name__ + ": "+ str(e), http_code=vimconn.HTTP_Bad_Request)
2177 except Exception as e
:
2180 server_id
= server
.id
2183 self
.delete_vminstance(server_id
, created_items
)
2184 except Exception as e2
:
2185 self
.logger
.error("new_vminstance rollback fail {}".format(e2
))
2187 self
._format
_exception
(e
)
2189 def get_vminstance(self
, vm_id
):
2190 """Returns the VM instance information from VIM"""
2191 # self.logger.debug("Getting VM from VIM")
2193 self
._reload
_connection
()
2194 server
= self
.nova
.servers
.find(id=vm_id
)
2195 # TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
2197 return server
.to_dict()
2199 ksExceptions
.ClientException
,
2200 nvExceptions
.ClientException
,
2201 nvExceptions
.NotFound
,
2204 self
._format
_exception
(e
)
2206 def get_vminstance_console(self
, vm_id
, console_type
="vnc"):
2208 Get a console for the virtual machine
2210 vm_id: uuid of the VM
2211 console_type, can be:
2212 "novnc" (by default), "xvpvnc" for VNC types,
2213 "rdp-html5" for RDP types, "spice-html5" for SPICE types
2214 Returns dict with the console parameters:
2215 protocol: ssh, ftp, http, https, ...
2216 server: usually ip address
2217 port: the http, ssh, ... port
2218 suffix: extra text, e.g. the http path and query string
2220 self
.logger
.debug("Getting VM CONSOLE from VIM")
2223 self
._reload
_connection
()
2224 server
= self
.nova
.servers
.find(id=vm_id
)
2226 if console_type
is None or console_type
== "novnc":
2227 console_dict
= server
.get_vnc_console("novnc")
2228 elif console_type
== "xvpvnc":
2229 console_dict
= server
.get_vnc_console(console_type
)
2230 elif console_type
== "rdp-html5":
2231 console_dict
= server
.get_rdp_console(console_type
)
2232 elif console_type
== "spice-html5":
2233 console_dict
= server
.get_spice_console(console_type
)
2235 raise vimconn
.VimConnException(
2236 "console type '{}' not allowed".format(console_type
),
2237 http_code
=vimconn
.HTTP_Bad_Request
,
2240 console_dict1
= console_dict
.get("console")
2243 console_url
= console_dict1
.get("url")
2247 protocol_index
= console_url
.find("//")
2249 console_url
[protocol_index
+ 2 :].find("/") + protocol_index
+ 2
2252 console_url
[protocol_index
+ 2 : suffix_index
].find(":")
2257 if protocol_index
< 0 or port_index
< 0 or suffix_index
< 0:
2259 -vimconn
.HTTP_Internal_Server_Error
,
2260 "Unexpected response from VIM",
2264 "protocol": console_url
[0:protocol_index
],
2265 "server": console_url
[protocol_index
+ 2 : port_index
],
2266 "port": console_url
[port_index
:suffix_index
],
2267 "suffix": console_url
[suffix_index
+ 1 :],
2272 raise vimconn
.VimConnUnexpectedResponse("Unexpected response from VIM")
2274 nvExceptions
.NotFound
,
2275 ksExceptions
.ClientException
,
2276 nvExceptions
.ClientException
,
2277 nvExceptions
.BadRequest
,
2280 self
._format
_exception
(e
)
2282 def delete_vminstance(self
, vm_id
, created_items
=None, volumes_to_hold
=None):
2283 """Removes a VM instance from VIM. Returns the old identifier"""
2284 # print "osconnector: Getting VM from VIM"
2285 if created_items
is None:
2289 self
._reload
_connection
()
2290 # delete VM ports attached to this networks before the virtual machine
2291 for k
, v
in created_items
.items():
2292 if not v
: # skip already deleted
2296 k_item
, _
, k_id
= k
.partition(":")
2297 if k_item
== "port":
2298 self
.neutron
.delete_port(k_id
)
2299 except Exception as e
:
2301 "Error deleting port: {}: {}".format(type(e
).__name
__, e
)
2304 # #commented because detaching the volumes makes the servers.delete not work properly ?!?
2305 # #dettach volumes attached
2306 # server = self.nova.servers.get(vm_id)
2307 # volumes_attached_dict = server._info["os-extended-volumes:volumes_attached"] #volume["id"]
2308 # #for volume in volumes_attached_dict:
2309 # # self.cinder.volumes.detach(volume["id"])
2312 self
.nova
.servers
.delete(vm_id
)
2314 # delete volumes. Although having detached, they should have in active status before deleting
2315 # we ensure in this loop
2319 while keep_waiting
and elapsed_time
< volume_timeout
:
2320 keep_waiting
= False
2322 for k
, v
in created_items
.items():
2323 if not v
: # skip already deleted
2327 k_item
, _
, k_id
= k
.partition(":")
2328 if k_item
== "volume":
2329 if self
.cinder
.volumes
.get(k_id
).status
!= "available":
2332 if k_id
not in volumes_to_hold
:
2333 self
.cinder
.volumes
.delete(k_id
)
2334 created_items
[k
] = None
2335 elif k_item
== "floating_ip": # floating ip
2336 self
.neutron
.delete_floatingip(k_id
)
2337 created_items
[k
] = None
2339 except Exception as e
:
2340 self
.logger
.error("Error deleting {}: {}".format(k
, e
))
2348 nvExceptions
.NotFound
,
2349 ksExceptions
.ClientException
,
2350 nvExceptions
.ClientException
,
2353 self
._format
_exception
(e
)
2355 def refresh_vms_status(self
, vm_list
):
2356 """Get the status of the virtual machines and their interfaces/ports
2357 Params: the list of VM identifiers
2358 Returns a dictionary with:
2359 vm_id: #VIM id of this Virtual Machine
2360 status: #Mandatory. Text with one of:
2361 # DELETED (not found at vim)
2362 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
2363 # OTHER (Vim reported other status not understood)
2364 # ERROR (VIM indicates an ERROR status)
2365 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
2366 # CREATING (on building process), ERROR
2367 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
2369 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
2370 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
2372 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
2373 mac_address: #Text format XX:XX:XX:XX:XX:XX
2374 vim_net_id: #network id where this interface is connected
2375 vim_interface_id: #interface/port VIM id
2376 ip_address: #null, or text with IPv4, IPv6 address
2377 compute_node: #identification of compute node where PF,VF interface is allocated
2378 pci: #PCI address of the NIC that hosts the PF,VF
2379 vlan: #physical VLAN used for VF
2383 "refresh_vms status: Getting tenant VM instance information from VIM"
2386 for vm_id
in vm_list
:
2390 vm_vim
= self
.get_vminstance(vm_id
)
2392 if vm_vim
["status"] in vmStatus2manoFormat
:
2393 vm
["status"] = vmStatus2manoFormat
[vm_vim
["status"]]
2395 vm
["status"] = "OTHER"
2396 vm
["error_msg"] = "VIM status reported " + vm_vim
["status"]
2398 vm_vim
.pop("OS-EXT-SRV-ATTR:user_data", None)
2399 vm_vim
.pop("user_data", None)
2400 vm
["vim_info"] = self
.serialize(vm_vim
)
2402 vm
["interfaces"] = []
2403 if vm_vim
.get("fault"):
2404 vm
["error_msg"] = str(vm_vim
["fault"])
2408 self
._reload
_connection
()
2409 port_dict
= self
.neutron
.list_ports(device_id
=vm_id
)
2411 for port
in port_dict
["ports"]:
2413 interface
["vim_info"] = self
.serialize(port
)
2414 interface
["mac_address"] = port
.get("mac_address")
2415 interface
["vim_net_id"] = port
["network_id"]
2416 interface
["vim_interface_id"] = port
["id"]
2417 # check if OS-EXT-SRV-ATTR:host is there,
2418 # in case of non-admin credentials, it will be missing
2420 if vm_vim
.get("OS-EXT-SRV-ATTR:host"):
2421 interface
["compute_node"] = vm_vim
["OS-EXT-SRV-ATTR:host"]
2423 interface
["pci"] = None
2425 # check if binding:profile is there,
2426 # in case of non-admin credentials, it will be missing
2427 if port
.get("binding:profile"):
2428 if port
["binding:profile"].get("pci_slot"):
2429 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting
2431 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
2432 # CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2) assuming there are 2 ports per nic
2433 pci
= port
["binding:profile"]["pci_slot"]
2434 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
2435 interface
["pci"] = pci
2437 interface
["vlan"] = None
2439 if port
.get("binding:vif_details"):
2440 interface
["vlan"] = port
["binding:vif_details"].get("vlan")
2442 # Get vlan from network in case not present in port for those old openstacks and cases where
2443 # it is needed vlan at PT
2444 if not interface
["vlan"]:
2445 # if network is of type vlan and port is of type direct (sr-iov) then set vlan id
2446 network
= self
.neutron
.show_network(port
["network_id"])
2449 network
["network"].get("provider:network_type")
2452 # and port.get("binding:vnic_type") in ("direct", "direct-physical"):
2453 interface
["vlan"] = network
["network"].get(
2454 "provider:segmentation_id"
2458 # look for floating ip address
2460 floating_ip_dict
= self
.neutron
.list_floatingips(
2464 if floating_ip_dict
.get("floatingips"):
2466 floating_ip_dict
["floatingips"][0].get(
2467 "floating_ip_address"
2473 for subnet
in port
["fixed_ips"]:
2474 ips
.append(subnet
["ip_address"])
2476 interface
["ip_address"] = ";".join(ips
)
2477 vm
["interfaces"].append(interface
)
2478 except Exception as e
:
2480 "Error getting vm interface information {}: {}".format(
2485 except vimconn
.VimConnNotFoundException
as e
:
2486 self
.logger
.error("Exception getting vm status: %s", str(e
))
2487 vm
["status"] = "DELETED"
2488 vm
["error_msg"] = str(e
)
2489 except vimconn
.VimConnException
as e
:
2490 self
.logger
.error("Exception getting vm status: %s", str(e
))
2491 vm
["status"] = "VIM_ERROR"
2492 vm
["error_msg"] = str(e
)
2498 def action_vminstance(self
, vm_id
, action_dict
, created_items
={}):
2499 """Send and action over a VM instance from VIM
2500 Returns None or the console dict if the action was successfully sent to the VIM"""
2501 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
2504 self
._reload
_connection
()
2505 server
= self
.nova
.servers
.find(id=vm_id
)
2507 if "start" in action_dict
:
2508 if action_dict
["start"] == "rebuild":
2511 if server
.status
== "PAUSED":
2513 elif server
.status
== "SUSPENDED":
2515 elif server
.status
== "SHUTOFF":
2517 elif "pause" in action_dict
:
2519 elif "resume" in action_dict
:
2521 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
2523 elif "forceOff" in action_dict
:
2524 server
.stop() # TODO
2525 elif "terminate" in action_dict
:
2527 elif "createImage" in action_dict
:
2528 server
.create_image()
2529 # "path":path_schema,
2530 # "description":description_schema,
2531 # "name":name_schema,
2532 # "metadata":metadata_schema,
2533 # "imageRef": id_schema,
2534 # "disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
2535 elif "rebuild" in action_dict
:
2536 server
.rebuild(server
.image
["id"])
2537 elif "reboot" in action_dict
:
2538 server
.reboot() # reboot_type="SOFT"
2539 elif "console" in action_dict
:
2540 console_type
= action_dict
["console"]
2542 if console_type
is None or console_type
== "novnc":
2543 console_dict
= server
.get_vnc_console("novnc")
2544 elif console_type
== "xvpvnc":
2545 console_dict
= server
.get_vnc_console(console_type
)
2546 elif console_type
== "rdp-html5":
2547 console_dict
= server
.get_rdp_console(console_type
)
2548 elif console_type
== "spice-html5":
2549 console_dict
= server
.get_spice_console(console_type
)
2551 raise vimconn
.VimConnException(
2552 "console type '{}' not allowed".format(console_type
),
2553 http_code
=vimconn
.HTTP_Bad_Request
,
2557 console_url
= console_dict
["console"]["url"]
2559 protocol_index
= console_url
.find("//")
2561 console_url
[protocol_index
+ 2 :].find("/") + protocol_index
+ 2
2564 console_url
[protocol_index
+ 2 : suffix_index
].find(":")
2569 if protocol_index
< 0 or port_index
< 0 or suffix_index
< 0:
2570 raise vimconn
.VimConnException(
2571 "Unexpected response from VIM " + str(console_dict
)
2575 "protocol": console_url
[0:protocol_index
],
2576 "server": console_url
[protocol_index
+ 2 : port_index
],
2577 "port": int(console_url
[port_index
+ 1 : suffix_index
]),
2578 "suffix": console_url
[suffix_index
+ 1 :],
2581 return console_dict2
2583 raise vimconn
.VimConnException(
2584 "Unexpected response from VIM " + str(console_dict
)
2589 ksExceptions
.ClientException
,
2590 nvExceptions
.ClientException
,
2591 nvExceptions
.NotFound
,
2594 self
._format
_exception
(e
)
2595 # TODO insert exception vimconn.HTTP_Unauthorized
2597 # ###### VIO Specific Changes #########
2598 def _generate_vlanID(self
):
2600 Method to get unused vlanID
2608 networks
= self
.get_network_list()
2610 for net
in networks
:
2611 if net
.get("provider:segmentation_id"):
2612 usedVlanIDs
.append(net
.get("provider:segmentation_id"))
2614 used_vlanIDs
= set(usedVlanIDs
)
2616 # find unused VLAN ID
2617 for vlanID_range
in self
.config
.get("dataplane_net_vlan_range"):
2619 start_vlanid
, end_vlanid
= map(
2620 int, vlanID_range
.replace(" ", "").split("-")
2623 for vlanID
in range(start_vlanid
, end_vlanid
+ 1):
2624 if vlanID
not in used_vlanIDs
:
2626 except Exception as exp
:
2627 raise vimconn
.VimConnException(
2628 "Exception {} occurred while generating VLAN ID.".format(exp
)
2631 raise vimconn
.VimConnConflictException(
2632 "Unable to create the SRIOV VLAN network. All given Vlan IDs {} are in use.".format(
2633 self
.config
.get("dataplane_net_vlan_range")
2637 def _generate_multisegment_vlanID(self
):
2639 Method to get unused vlanID
2647 networks
= self
.get_network_list()
2648 for net
in networks
:
2649 if net
.get("provider:network_type") == "vlan" and net
.get(
2650 "provider:segmentation_id"
2652 usedVlanIDs
.append(net
.get("provider:segmentation_id"))
2653 elif net
.get("segments"):
2654 for segment
in net
.get("segments"):
2655 if segment
.get("provider:network_type") == "vlan" and segment
.get(
2656 "provider:segmentation_id"
2658 usedVlanIDs
.append(segment
.get("provider:segmentation_id"))
2660 used_vlanIDs
= set(usedVlanIDs
)
2662 # find unused VLAN ID
2663 for vlanID_range
in self
.config
.get("multisegment_vlan_range"):
2665 start_vlanid
, end_vlanid
= map(
2666 int, vlanID_range
.replace(" ", "").split("-")
2669 for vlanID
in range(start_vlanid
, end_vlanid
+ 1):
2670 if vlanID
not in used_vlanIDs
:
2672 except Exception as exp
:
2673 raise vimconn
.VimConnException(
2674 "Exception {} occurred while generating VLAN ID.".format(exp
)
2677 raise vimconn
.VimConnConflictException(
2678 "Unable to create the VLAN segment. All VLAN IDs {} are in use.".format(
2679 self
.config
.get("multisegment_vlan_range")
2683 def _validate_vlan_ranges(self
, input_vlan_range
, text_vlan_range
):
2685 Method to validate user given vlanID ranges
2689 for vlanID_range
in input_vlan_range
:
2690 vlan_range
= vlanID_range
.replace(" ", "")
2692 vlanID_pattern
= r
"(\d)*-(\d)*$"
2693 match_obj
= re
.match(vlanID_pattern
, vlan_range
)
2695 raise vimconn
.VimConnConflictException(
2696 "Invalid VLAN range for {}: {}.You must provide "
2697 "'{}' in format [start_ID - end_ID].".format(
2698 text_vlan_range
, vlanID_range
, text_vlan_range
2702 start_vlanid
, end_vlanid
= map(int, vlan_range
.split("-"))
2703 if start_vlanid
<= 0:
2704 raise vimconn
.VimConnConflictException(
2705 "Invalid VLAN range for {}: {}. Start ID can not be zero. For VLAN "
2706 "networks valid IDs are 1 to 4094 ".format(
2707 text_vlan_range
, vlanID_range
2711 if end_vlanid
> 4094:
2712 raise vimconn
.VimConnConflictException(
2713 "Invalid VLAN range for {}: {}. End VLAN ID can not be "
2714 "greater than 4094. For VLAN networks valid IDs are 1 to 4094 ".format(
2715 text_vlan_range
, vlanID_range
2719 if start_vlanid
> end_vlanid
:
2720 raise vimconn
.VimConnConflictException(
2721 "Invalid VLAN range for {}: {}. You must provide '{}'"
2722 " in format start_ID - end_ID and start_ID < end_ID ".format(
2723 text_vlan_range
, vlanID_range
, text_vlan_range
2727 # NOT USED FUNCTIONS
2729 def new_external_port(self
, port_data
):
2730 """Adds a external port to VIM
2731 Returns the port identifier"""
2732 # TODO openstack if needed
2734 -vimconn
.HTTP_Internal_Server_Error
,
2735 "osconnector.new_external_port() not implemented",
2738 def connect_port_network(self
, port_id
, network_id
, admin
=False):
2739 """Connects a external port to a network
2740 Returns status code of the VIM response"""
2741 # TODO openstack if needed
2743 -vimconn
.HTTP_Internal_Server_Error
,
2744 "osconnector.connect_port_network() not implemented",
2747 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
2748 """Adds a new user to openstack VIM
2749 Returns the user identifier"""
2750 self
.logger
.debug("osconnector: Adding a new user to VIM")
2753 self
._reload
_connection
()
2754 user
= self
.keystone
.users
.create(
2755 user_name
, password
=user_passwd
, default_project
=tenant_id
2757 # self.keystone.tenants.add_user(self.k_creds["username"], #role)
2760 except ksExceptions
.ConnectionError
as e
:
2761 error_value
= -vimconn
.HTTP_Bad_Request
2765 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2767 except ksExceptions
.ClientException
as e
: # TODO remove
2768 error_value
= -vimconn
.HTTP_Bad_Request
2772 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2775 # TODO insert exception vimconn.HTTP_Unauthorized
2776 # if reaching here is because an exception
2777 self
.logger
.debug("new_user " + error_text
)
2779 return error_value
, error_text
2781 def delete_user(self
, user_id
):
2782 """Delete a user from openstack VIM
2783 Returns the user identifier"""
2785 print("osconnector: Deleting a user from VIM")
2788 self
._reload
_connection
()
2789 self
.keystone
.users
.delete(user_id
)
2792 except ksExceptions
.ConnectionError
as e
:
2793 error_value
= -vimconn
.HTTP_Bad_Request
2797 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2799 except ksExceptions
.NotFound
as e
:
2800 error_value
= -vimconn
.HTTP_Not_Found
2804 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2806 except ksExceptions
.ClientException
as e
: # TODO remove
2807 error_value
= -vimconn
.HTTP_Bad_Request
2811 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2814 # TODO insert exception vimconn.HTTP_Unauthorized
2815 # if reaching here is because an exception
2816 self
.logger
.debug("delete_tenant " + error_text
)
2818 return error_value
, error_text
2820 def get_hosts_info(self
):
2821 """Get the information of deployed hosts
2822 Returns the hosts content"""
2824 print("osconnector: Getting Host info from VIM")
2828 self
._reload
_connection
()
2829 hypervisors
= self
.nova
.hypervisors
.list()
2831 for hype
in hypervisors
:
2832 h_list
.append(hype
.to_dict())
2834 return 1, {"hosts": h_list
}
2835 except nvExceptions
.NotFound
as e
:
2836 error_value
= -vimconn
.HTTP_Not_Found
2837 error_text
= str(e
) if len(e
.args
) == 0 else str(e
.args
[0])
2838 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
2839 error_value
= -vimconn
.HTTP_Bad_Request
2843 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2846 # TODO insert exception vimconn.HTTP_Unauthorized
2847 # if reaching here is because an exception
2848 self
.logger
.debug("get_hosts_info " + error_text
)
2850 return error_value
, error_text
2852 def get_hosts(self
, vim_tenant
):
2853 """Get the hosts and deployed instances
2854 Returns the hosts content"""
2855 r
, hype_dict
= self
.get_hosts_info()
2860 hypervisors
= hype_dict
["hosts"]
2863 servers
= self
.nova
.servers
.list()
2864 for hype
in hypervisors
:
2865 for server
in servers
:
2867 server
.to_dict()["OS-EXT-SRV-ATTR:hypervisor_hostname"]
2868 == hype
["hypervisor_hostname"]
2871 hype
["vm"].append(server
.id)
2873 hype
["vm"] = [server
.id]
2876 except nvExceptions
.NotFound
as e
:
2877 error_value
= -vimconn
.HTTP_Not_Found
2878 error_text
= str(e
) if len(e
.args
) == 0 else str(e
.args
[0])
2879 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
2880 error_value
= -vimconn
.HTTP_Bad_Request
2884 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
2887 # TODO insert exception vimconn.HTTP_Unauthorized
2888 # if reaching here is because an exception
2889 self
.logger
.debug("get_hosts " + error_text
)
2891 return error_value
, error_text
2893 def new_classification(self
, name
, ctype
, definition
):
2895 "Adding a new (Traffic) Classification to VIM, named %s", name
2900 self
._reload
_connection
()
2902 if ctype
not in supportedClassificationTypes
:
2903 raise vimconn
.VimConnNotSupportedException(
2904 "OpenStack VIM connector does not support provided "
2905 "Classification Type {}, supported ones are: {}".format(
2906 ctype
, supportedClassificationTypes
2910 if not self
._validate
_classification
(ctype
, definition
):
2911 raise vimconn
.VimConnException(
2912 "Incorrect Classification definition for the type specified."
2915 classification_dict
= definition
2916 classification_dict
["name"] = name
2917 new_class
= self
.neutron
.create_sfc_flow_classifier(
2918 {"flow_classifier": classification_dict
}
2921 return new_class
["flow_classifier"]["id"]
2923 neExceptions
.ConnectionFailed
,
2924 ksExceptions
.ClientException
,
2925 neExceptions
.NeutronException
,
2928 self
.logger
.error("Creation of Classification failed.")
2929 self
._format
_exception
(e
)
2931 def get_classification(self
, class_id
):
2932 self
.logger
.debug(" Getting Classification %s from VIM", class_id
)
2933 filter_dict
= {"id": class_id
}
2934 class_list
= self
.get_classification_list(filter_dict
)
2936 if len(class_list
) == 0:
2937 raise vimconn
.VimConnNotFoundException(
2938 "Classification '{}' not found".format(class_id
)
2940 elif len(class_list
) > 1:
2941 raise vimconn
.VimConnConflictException(
2942 "Found more than one Classification with this criteria"
2945 classification
= class_list
[0]
2947 return classification
2949 def get_classification_list(self
, filter_dict
={}):
2951 "Getting Classifications from VIM filter: '%s'", str(filter_dict
)
2955 filter_dict_os
= filter_dict
.copy()
2956 self
._reload
_connection
()
2958 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2959 filter_dict_os
["project_id"] = filter_dict_os
.pop("tenant_id")
2961 classification_dict
= self
.neutron
.list_sfc_flow_classifiers(
2964 classification_list
= classification_dict
["flow_classifiers"]
2965 self
.__classification
_os
2mano
(classification_list
)
2967 return classification_list
2969 neExceptions
.ConnectionFailed
,
2970 ksExceptions
.ClientException
,
2971 neExceptions
.NeutronException
,
2974 self
._format
_exception
(e
)
2976 def delete_classification(self
, class_id
):
2977 self
.logger
.debug("Deleting Classification '%s' from VIM", class_id
)
2980 self
._reload
_connection
()
2981 self
.neutron
.delete_sfc_flow_classifier(class_id
)
2985 neExceptions
.ConnectionFailed
,
2986 neExceptions
.NeutronException
,
2987 ksExceptions
.ClientException
,
2988 neExceptions
.NeutronException
,
2991 self
._format
_exception
(e
)
2993 def new_sfi(self
, name
, ingress_ports
, egress_ports
, sfc_encap
=True):
2995 "Adding a new Service Function Instance to VIM, named '%s'", name
3000 self
._reload
_connection
()
3006 if len(ingress_ports
) != 1:
3007 raise vimconn
.VimConnNotSupportedException(
3008 "OpenStack VIM connector can only have 1 ingress port per SFI"
3011 if len(egress_ports
) != 1:
3012 raise vimconn
.VimConnNotSupportedException(
3013 "OpenStack VIM connector can only have 1 egress port per SFI"
3018 "ingress": ingress_ports
[0],
3019 "egress": egress_ports
[0],
3020 "service_function_parameters": {"correlation": correlation
},
3022 new_sfi
= self
.neutron
.create_sfc_port_pair({"port_pair": sfi_dict
})
3024 return new_sfi
["port_pair"]["id"]
3026 neExceptions
.ConnectionFailed
,
3027 ksExceptions
.ClientException
,
3028 neExceptions
.NeutronException
,
3033 self
.neutron
.delete_sfc_port_pair(new_sfi
["port_pair"]["id"])
3036 "Creation of Service Function Instance failed, with "
3037 "subsequent deletion failure as well."
3040 self
._format
_exception
(e
)
3042 def get_sfi(self
, sfi_id
):
3043 self
.logger
.debug("Getting Service Function Instance %s from VIM", sfi_id
)
3044 filter_dict
= {"id": sfi_id
}
3045 sfi_list
= self
.get_sfi_list(filter_dict
)
3047 if len(sfi_list
) == 0:
3048 raise vimconn
.VimConnNotFoundException(
3049 "Service Function Instance '{}' not found".format(sfi_id
)
3051 elif len(sfi_list
) > 1:
3052 raise vimconn
.VimConnConflictException(
3053 "Found more than one Service Function Instance with this criteria"
3060 def get_sfi_list(self
, filter_dict
={}):
3062 "Getting Service Function Instances from VIM filter: '%s'", str(filter_dict
)
3066 self
._reload
_connection
()
3067 filter_dict_os
= filter_dict
.copy()
3069 if self
.api_version3
and "tenant_id" in filter_dict_os
:
3070 filter_dict_os
["project_id"] = filter_dict_os
.pop("tenant_id")
3072 sfi_dict
= self
.neutron
.list_sfc_port_pairs(**filter_dict_os
)
3073 sfi_list
= sfi_dict
["port_pairs"]
3074 self
.__sfi
_os
2mano
(sfi_list
)
3078 neExceptions
.ConnectionFailed
,
3079 ksExceptions
.ClientException
,
3080 neExceptions
.NeutronException
,
3083 self
._format
_exception
(e
)
3085 def delete_sfi(self
, sfi_id
):
3086 self
.logger
.debug("Deleting Service Function Instance '%s' from VIM", sfi_id
)
3089 self
._reload
_connection
()
3090 self
.neutron
.delete_sfc_port_pair(sfi_id
)
3094 neExceptions
.ConnectionFailed
,
3095 neExceptions
.NeutronException
,
3096 ksExceptions
.ClientException
,
3097 neExceptions
.NeutronException
,
3100 self
._format
_exception
(e
)
3102 def new_sf(self
, name
, sfis
, sfc_encap
=True):
3103 self
.logger
.debug("Adding a new Service Function to VIM, named '%s'", name
)
3107 self
._reload
_connection
()
3108 # correlation = None
3110 # correlation = "nsh"
3112 for instance
in sfis
:
3113 sfi
= self
.get_sfi(instance
)
3115 if sfi
.get("sfc_encap") != sfc_encap
:
3116 raise vimconn
.VimConnNotSupportedException(
3117 "OpenStack VIM connector requires all SFIs of the "
3118 "same SF to share the same SFC Encapsulation"
3121 sf_dict
= {"name": name
, "port_pairs": sfis
}
3122 new_sf
= self
.neutron
.create_sfc_port_pair_group(
3123 {"port_pair_group": sf_dict
}
3126 return new_sf
["port_pair_group"]["id"]
3128 neExceptions
.ConnectionFailed
,
3129 ksExceptions
.ClientException
,
3130 neExceptions
.NeutronException
,
3135 self
.neutron
.delete_sfc_port_pair_group(
3136 new_sf
["port_pair_group"]["id"]
3140 "Creation of Service Function failed, with "
3141 "subsequent deletion failure as well."
3144 self
._format
_exception
(e
)
3146 def get_sf(self
, sf_id
):
3147 self
.logger
.debug("Getting Service Function %s from VIM", sf_id
)
3148 filter_dict
= {"id": sf_id
}
3149 sf_list
= self
.get_sf_list(filter_dict
)
3151 if len(sf_list
) == 0:
3152 raise vimconn
.VimConnNotFoundException(
3153 "Service Function '{}' not found".format(sf_id
)
3155 elif len(sf_list
) > 1:
3156 raise vimconn
.VimConnConflictException(
3157 "Found more than one Service Function with this criteria"
3164 def get_sf_list(self
, filter_dict
={}):
3166 "Getting Service Function from VIM filter: '%s'", str(filter_dict
)
3170 self
._reload
_connection
()
3171 filter_dict_os
= filter_dict
.copy()
3173 if self
.api_version3
and "tenant_id" in filter_dict_os
:
3174 filter_dict_os
["project_id"] = filter_dict_os
.pop("tenant_id")
3176 sf_dict
= self
.neutron
.list_sfc_port_pair_groups(**filter_dict_os
)
3177 sf_list
= sf_dict
["port_pair_groups"]
3178 self
.__sf
_os
2mano
(sf_list
)
3182 neExceptions
.ConnectionFailed
,
3183 ksExceptions
.ClientException
,
3184 neExceptions
.NeutronException
,
3187 self
._format
_exception
(e
)
3189 def delete_sf(self
, sf_id
):
3190 self
.logger
.debug("Deleting Service Function '%s' from VIM", sf_id
)
3193 self
._reload
_connection
()
3194 self
.neutron
.delete_sfc_port_pair_group(sf_id
)
3198 neExceptions
.ConnectionFailed
,
3199 neExceptions
.NeutronException
,
3200 ksExceptions
.ClientException
,
3201 neExceptions
.NeutronException
,
3204 self
._format
_exception
(e
)
3206 def new_sfp(self
, name
, classifications
, sfs
, sfc_encap
=True, spi
=None):
3207 self
.logger
.debug("Adding a new Service Function Path to VIM, named '%s'", name
)
3211 self
._reload
_connection
()
3212 # In networking-sfc the MPLS encapsulation is legacy
3213 # should be used when no full SFC Encapsulation is intended
3214 correlation
= "mpls"
3221 "flow_classifiers": classifications
,
3222 "port_pair_groups": sfs
,
3223 "chain_parameters": {"correlation": correlation
},
3227 sfp_dict
["chain_id"] = spi
3229 new_sfp
= self
.neutron
.create_sfc_port_chain({"port_chain": sfp_dict
})
3231 return new_sfp
["port_chain"]["id"]
3233 neExceptions
.ConnectionFailed
,
3234 ksExceptions
.ClientException
,
3235 neExceptions
.NeutronException
,
3240 self
.neutron
.delete_sfc_port_chain(new_sfp
["port_chain"]["id"])
3243 "Creation of Service Function Path failed, with "
3244 "subsequent deletion failure as well."
3247 self
._format
_exception
(e
)
3249 def get_sfp(self
, sfp_id
):
3250 self
.logger
.debug(" Getting Service Function Path %s from VIM", sfp_id
)
3252 filter_dict
= {"id": sfp_id
}
3253 sfp_list
= self
.get_sfp_list(filter_dict
)
3255 if len(sfp_list
) == 0:
3256 raise vimconn
.VimConnNotFoundException(
3257 "Service Function Path '{}' not found".format(sfp_id
)
3259 elif len(sfp_list
) > 1:
3260 raise vimconn
.VimConnConflictException(
3261 "Found more than one Service Function Path with this criteria"
3268 def get_sfp_list(self
, filter_dict
={}):
3270 "Getting Service Function Paths from VIM filter: '%s'", str(filter_dict
)
3274 self
._reload
_connection
()
3275 filter_dict_os
= filter_dict
.copy()
3277 if self
.api_version3
and "tenant_id" in filter_dict_os
:
3278 filter_dict_os
["project_id"] = filter_dict_os
.pop("tenant_id")
3280 sfp_dict
= self
.neutron
.list_sfc_port_chains(**filter_dict_os
)
3281 sfp_list
= sfp_dict
["port_chains"]
3282 self
.__sfp
_os
2mano
(sfp_list
)
3286 neExceptions
.ConnectionFailed
,
3287 ksExceptions
.ClientException
,
3288 neExceptions
.NeutronException
,
3291 self
._format
_exception
(e
)
3293 def delete_sfp(self
, sfp_id
):
3294 self
.logger
.debug("Deleting Service Function Path '%s' from VIM", sfp_id
)
3297 self
._reload
_connection
()
3298 self
.neutron
.delete_sfc_port_chain(sfp_id
)
3302 neExceptions
.ConnectionFailed
,
3303 neExceptions
.NeutronException
,
3304 ksExceptions
.ClientException
,
3305 neExceptions
.NeutronException
,
3308 self
._format
_exception
(e
)
3310 def refresh_sfps_status(self
, sfp_list
):
3311 """Get the status of the service function path
3312 Params: the list of sfp identifiers
3313 Returns a dictionary with:
3314 vm_id: #VIM id of this service function path
3315 status: #Mandatory. Text with one of:
3316 # DELETED (not found at vim)
3317 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
3318 # OTHER (Vim reported other status not understood)
3319 # ERROR (VIM indicates an ERROR status)
3321 # CREATING (on building process)
3322 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
3323 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)F
3327 "refresh_sfps status: Getting tenant SFP information from VIM"
3330 for sfp_id
in sfp_list
:
3334 sfp_vim
= self
.get_sfp(sfp_id
)
3337 sfp
["status"] = vmStatus2manoFormat
["ACTIVE"]
3339 sfp
["status"] = "OTHER"
3340 sfp
["error_msg"] = "VIM status reported " + sfp
["status"]
3342 sfp
["vim_info"] = self
.serialize(sfp_vim
)
3344 if sfp_vim
.get("fault"):
3345 sfp
["error_msg"] = str(sfp_vim
["fault"])
3346 except vimconn
.VimConnNotFoundException
as e
:
3347 self
.logger
.error("Exception getting sfp status: %s", str(e
))
3348 sfp
["status"] = "DELETED"
3349 sfp
["error_msg"] = str(e
)
3350 except vimconn
.VimConnException
as e
:
3351 self
.logger
.error("Exception getting sfp status: %s", str(e
))
3352 sfp
["status"] = "VIM_ERROR"
3353 sfp
["error_msg"] = str(e
)
3355 sfp_dict
[sfp_id
] = sfp
3359 def refresh_sfis_status(self
, sfi_list
):
3360 """Get the status of the service function instances
3361 Params: the list of sfi identifiers
3362 Returns a dictionary with:
3363 vm_id: #VIM id of this service function instance
3364 status: #Mandatory. Text with one of:
3365 # DELETED (not found at vim)
3366 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
3367 # OTHER (Vim reported other status not understood)
3368 # ERROR (VIM indicates an ERROR status)
3370 # CREATING (on building process)
3371 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
3372 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
3376 "refresh_sfis status: Getting tenant sfi information from VIM"
3379 for sfi_id
in sfi_list
:
3383 sfi_vim
= self
.get_sfi(sfi_id
)
3386 sfi
["status"] = vmStatus2manoFormat
["ACTIVE"]
3388 sfi
["status"] = "OTHER"
3389 sfi
["error_msg"] = "VIM status reported " + sfi
["status"]
3391 sfi
["vim_info"] = self
.serialize(sfi_vim
)
3393 if sfi_vim
.get("fault"):
3394 sfi
["error_msg"] = str(sfi_vim
["fault"])
3395 except vimconn
.VimConnNotFoundException
as e
:
3396 self
.logger
.error("Exception getting sfi status: %s", str(e
))
3397 sfi
["status"] = "DELETED"
3398 sfi
["error_msg"] = str(e
)
3399 except vimconn
.VimConnException
as e
:
3400 self
.logger
.error("Exception getting sfi status: %s", str(e
))
3401 sfi
["status"] = "VIM_ERROR"
3402 sfi
["error_msg"] = str(e
)
3404 sfi_dict
[sfi_id
] = sfi
3408 def refresh_sfs_status(self
, sf_list
):
3409 """Get the status of the service functions
3410 Params: the list of sf identifiers
3411 Returns a dictionary with:
3412 vm_id: #VIM id of this service function
3413 status: #Mandatory. Text with one of:
3414 # DELETED (not found at vim)
3415 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
3416 # OTHER (Vim reported other status not understood)
3417 # ERROR (VIM indicates an ERROR status)
3419 # CREATING (on building process)
3420 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
3421 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
3424 self
.logger
.debug("refresh_sfs status: Getting tenant sf information from VIM")
3426 for sf_id
in sf_list
:
3430 sf_vim
= self
.get_sf(sf_id
)
3433 sf
["status"] = vmStatus2manoFormat
["ACTIVE"]
3435 sf
["status"] = "OTHER"
3436 sf
["error_msg"] = "VIM status reported " + sf_vim
["status"]
3438 sf
["vim_info"] = self
.serialize(sf_vim
)
3440 if sf_vim
.get("fault"):
3441 sf
["error_msg"] = str(sf_vim
["fault"])
3442 except vimconn
.VimConnNotFoundException
as e
:
3443 self
.logger
.error("Exception getting sf status: %s", str(e
))
3444 sf
["status"] = "DELETED"
3445 sf
["error_msg"] = str(e
)
3446 except vimconn
.VimConnException
as e
:
3447 self
.logger
.error("Exception getting sf status: %s", str(e
))
3448 sf
["status"] = "VIM_ERROR"
3449 sf
["error_msg"] = str(e
)
3455 def refresh_classifications_status(self
, classification_list
):
3456 """Get the status of the classifications
3457 Params: the list of classification identifiers
3458 Returns a dictionary with:
3459 vm_id: #VIM id of this classifier
3460 status: #Mandatory. Text with one of:
3461 # DELETED (not found at vim)
3462 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
3463 # OTHER (Vim reported other status not understood)
3464 # ERROR (VIM indicates an ERROR status)
3466 # CREATING (on building process)
3467 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
3468 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
3470 classification_dict
= {}
3472 "refresh_classifications status: Getting tenant classification information from VIM"
3475 for classification_id
in classification_list
:
3479 classification_vim
= self
.get_classification(classification_id
)
3481 if classification_vim
:
3482 classification
["status"] = vmStatus2manoFormat
["ACTIVE"]
3484 classification
["status"] = "OTHER"
3485 classification
["error_msg"] = (
3486 "VIM status reported " + classification
["status"]
3489 classification
["vim_info"] = self
.serialize(classification_vim
)
3491 if classification_vim
.get("fault"):
3492 classification
["error_msg"] = str(classification_vim
["fault"])
3493 except vimconn
.VimConnNotFoundException
as e
:
3494 self
.logger
.error("Exception getting classification status: %s", str(e
))
3495 classification
["status"] = "DELETED"
3496 classification
["error_msg"] = str(e
)
3497 except vimconn
.VimConnException
as e
:
3498 self
.logger
.error("Exception getting classification status: %s", str(e
))
3499 classification
["status"] = "VIM_ERROR"
3500 classification
["error_msg"] = str(e
)
3502 classification_dict
[classification_id
] = classification
3504 return classification_dict
3506 def new_affinity_group(self
, affinity_group_data
):
3507 """Adds a server group to VIM
3508 affinity_group_data contains a dictionary with information, keys:
3509 name: name in VIM for the server group
3510 type: affinity or anti-affinity
3511 scope: Only nfvi-node allowed
3512 Returns the server group identifier"""
3513 self
.logger
.debug("Adding Server Group '%s'", str(affinity_group_data
))
3516 name
= affinity_group_data
["name"]
3517 policy
= affinity_group_data
["type"]
3519 self
._reload
_connection
()
3520 new_server_group
= self
.nova
.server_groups
.create(name
, policy
)
3522 return new_server_group
.id
3524 ksExceptions
.ClientException
,
3525 nvExceptions
.ClientException
,
3529 self
._format
_exception
(e
)
3531 def get_affinity_group(self
, affinity_group_id
):
3532 """Obtain server group details from the VIM. Returns the server group detais as a dict"""
3533 self
.logger
.debug("Getting flavor '%s'", affinity_group_id
)
3535 self
._reload
_connection
()
3536 server_group
= self
.nova
.server_groups
.find(id=affinity_group_id
)
3538 return server_group
.to_dict()
3540 nvExceptions
.NotFound
,
3541 nvExceptions
.ClientException
,
3542 ksExceptions
.ClientException
,
3545 self
._format
_exception
(e
)
3547 def delete_affinity_group(self
, affinity_group_id
):
3548 """Deletes a server group from the VIM. Returns the old affinity_group_id"""
3549 self
.logger
.debug("Getting server group '%s'", affinity_group_id
)
3551 self
._reload
_connection
()
3552 self
.nova
.server_groups
.delete(affinity_group_id
)
3554 return affinity_group_id
3556 nvExceptions
.NotFound
,
3557 ksExceptions
.ClientException
,
3558 nvExceptions
.ClientException
,
3561 self
._format
_exception
(e
)
3563 def get_vdu_state(self
, vm_id
):
3565 Getting the state of a vdu
3567 vm_id: ID of an instance
3569 self
.logger
.debug("Getting the status of VM")
3570 self
.logger
.debug("VIM VM ID %s", vm_id
)
3571 self
._reload
_connection
()
3572 server
= self
.nova
.servers
.find(id=vm_id
)
3573 server_dict
= server
.to_dict()
3575 server_dict
["status"],
3576 server_dict
["flavor"]["id"],
3577 server_dict
["OS-EXT-SRV-ATTR:host"],
3578 server_dict
["OS-EXT-AZ:availability_zone"],
3580 self
.logger
.debug("vdu_data %s", vdu_data
)
3583 def check_compute_availability(self
, host
, server_flavor_details
):
3584 self
._reload
_connection
()
3585 hypervisor_search
= self
.nova
.hypervisors
.search(
3586 hypervisor_match
=host
, servers
=True
3588 for hypervisor
in hypervisor_search
:
3589 hypervisor_id
= hypervisor
.to_dict()["id"]
3590 hypervisor_details
= self
.nova
.hypervisors
.get(hypervisor
=hypervisor_id
)
3591 hypervisor_dict
= hypervisor_details
.to_dict()
3592 hypervisor_temp
= json
.dumps(hypervisor_dict
)
3593 hypervisor_json
= json
.loads(hypervisor_temp
)
3594 resources_available
= [
3595 hypervisor_json
["free_ram_mb"],
3596 hypervisor_json
["disk_available_least"],
3597 hypervisor_json
["vcpus"] - hypervisor_json
["vcpus_used"],
3599 compute_available
= all(
3600 x
> y
for x
, y
in zip(resources_available
, server_flavor_details
)
3602 if compute_available
:
3605 def check_availability_zone(
3606 self
, old_az
, server_flavor_details
, old_host
, host
=None
3608 self
._reload
_connection
()
3609 az_check
= {"zone_check": False, "compute_availability": None}
3610 aggregates_list
= self
.nova
.aggregates
.list()
3611 for aggregate
in aggregates_list
:
3612 aggregate_details
= aggregate
.to_dict()
3613 aggregate_temp
= json
.dumps(aggregate_details
)
3614 aggregate_json
= json
.loads(aggregate_temp
)
3615 if aggregate_json
["availability_zone"] == old_az
:
3616 hosts_list
= aggregate_json
["hosts"]
3617 if host
is not None:
3618 if host
in hosts_list
:
3619 az_check
["zone_check"] = True
3620 available_compute_id
= self
.check_compute_availability(
3621 host
, server_flavor_details
3623 if available_compute_id
is not None:
3624 az_check
["compute_availability"] = available_compute_id
3626 for check_host
in hosts_list
:
3627 if check_host
!= old_host
:
3628 available_compute_id
= self
.check_compute_availability(
3629 check_host
, server_flavor_details
3631 if available_compute_id
is not None:
3632 az_check
["zone_check"] = True
3633 az_check
["compute_availability"] = available_compute_id
3636 az_check
["zone_check"] = True
3639 def migrate_instance(self
, vm_id
, compute_host
=None):
3643 vm_id: ID of an instance
3644 compute_host: Host to migrate the vdu to
3646 self
._reload
_connection
()
3648 instance_state
= self
.get_vdu_state(vm_id
)
3649 server_flavor_id
= instance_state
[1]
3650 server_hypervisor_name
= instance_state
[2]
3651 server_availability_zone
= instance_state
[3]
3653 server_flavor
= self
.nova
.flavors
.find(id=server_flavor_id
).to_dict()
3654 server_flavor_details
= [
3655 server_flavor
["ram"],
3656 server_flavor
["disk"],
3657 server_flavor
["vcpus"],
3659 if compute_host
== server_hypervisor_name
:
3660 raise vimconn
.VimConnException(
3661 "Unable to migrate instance '{}' to the same host '{}'".format(
3664 http_code
=vimconn
.HTTP_Bad_Request
,
3666 az_status
= self
.check_availability_zone(
3667 server_availability_zone
,
3668 server_flavor_details
,
3669 server_hypervisor_name
,
3672 availability_zone_check
= az_status
["zone_check"]
3673 available_compute_id
= az_status
.get("compute_availability")
3675 if availability_zone_check
is False:
3676 raise vimconn
.VimConnException(
3677 "Unable to migrate instance '{}' to a different availability zone".format(
3680 http_code
=vimconn
.HTTP_Bad_Request
,
3682 if available_compute_id
is not None:
3683 self
.nova
.servers
.live_migrate(
3685 host
=available_compute_id
,
3686 block_migration
=True,
3687 disk_over_commit
=False,
3690 changed_compute_host
= ""
3691 if state
== "MIGRATING":
3692 vm_state
= self
.__wait
_for
_vm
(vm_id
, "ACTIVE")
3693 changed_compute_host
= self
.get_vdu_state(vm_id
)[2]
3694 if vm_state
and changed_compute_host
== available_compute_id
:
3696 "Instance '{}' migrated to the new compute host '{}'".format(
3697 vm_id
, changed_compute_host
3700 return state
, available_compute_id
3702 raise vimconn
.VimConnException(
3703 "Migration Failed. Instance '{}' not moved to the new host {}".format(
3704 vm_id
, available_compute_id
3706 http_code
=vimconn
.HTTP_Bad_Request
,
3709 raise vimconn
.VimConnException(
3710 "Compute '{}' not available or does not have enough resources to migrate the instance".format(
3711 available_compute_id
3713 http_code
=vimconn
.HTTP_Bad_Request
,
3716 nvExceptions
.BadRequest
,
3717 nvExceptions
.ClientException
,
3718 nvExceptions
.NotFound
,
3720 self
._format
_exception
(e
)