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
41 from typing
import Dict
, List
, Optional
, Tuple
43 from cinderclient
import client
as cClient
44 from glanceclient
import client
as glClient
45 import glanceclient
.exc
as gl1Exceptions
46 from keystoneauth1
import session
47 from keystoneauth1
.identity
import v2
, v3
48 import keystoneclient
.exceptions
as ksExceptions
49 import keystoneclient
.v2_0
.client
as ksClient_v2
50 import keystoneclient
.v3
.client
as ksClient_v3
52 from neutronclient
.common
import exceptions
as neExceptions
53 from neutronclient
.neutron
import client
as neClient
54 from novaclient
import client
as nClient
, exceptions
as nvExceptions
55 from osm_ro_plugin
import vimconn
56 from requests
.exceptions
import ConnectionError
59 __author__
= "Alfonso Tierno, Gerardo Garcia, Pablo Montes, xFlow Research, Igor D.C., Eduardo Sousa"
60 __date__
= "$22-sep-2017 23:59:59$"
62 """contain the openstack virtual machine status to openmano status"""
63 vmStatus2manoFormat
= {
66 "SUSPENDED": "SUSPENDED",
67 "SHUTOFF": "INACTIVE",
72 netStatus2manoFormat
= {
75 "INACTIVE": "INACTIVE",
81 supportedClassificationTypes
= ["legacy_flow_classifier"]
83 # global var to have a timeout creating and deleting volumes
88 class SafeDumper(yaml
.SafeDumper
):
89 def represent_data(self
, data
):
90 # Openstack APIs use custom subclasses of dict and YAML safe dumper
91 # is designed to not handle that (reference issue 142 of pyyaml)
92 if isinstance(data
, dict) and data
.__class
__ != dict:
93 # A simple solution is to convert those items back to dicts
94 data
= dict(data
.items())
96 return super(SafeDumper
, self
).represent_data(data
)
99 class vimconnector(vimconn
.VimConnector
):
114 """using common constructor parameters. In this case
115 'url' is the keystone authorization url,
116 'url_admin' is not use
118 api_version
= config
.get("APIversion")
120 if api_version
and api_version
not in ("v3.3", "v2.0", "2", "3"):
121 raise vimconn
.VimConnException(
122 "Invalid value '{}' for config:APIversion. "
123 "Allowed values are 'v3.3', 'v2.0', '2' or '3'".format(api_version
)
126 vim_type
= config
.get("vim_type")
128 if vim_type
and vim_type
not in ("vio", "VIO"):
129 raise vimconn
.VimConnException(
130 "Invalid value '{}' for config:vim_type."
131 "Allowed values are 'vio' or 'VIO'".format(vim_type
)
134 if config
.get("dataplane_net_vlan_range") is not None:
135 # validate vlan ranges provided by user
136 self
._validate
_vlan
_ranges
(
137 config
.get("dataplane_net_vlan_range"), "dataplane_net_vlan_range"
140 if config
.get("multisegment_vlan_range") is not None:
141 # validate vlan ranges provided by user
142 self
._validate
_vlan
_ranges
(
143 config
.get("multisegment_vlan_range"), "multisegment_vlan_range"
146 vimconn
.VimConnector
.__init
__(
160 if self
.config
.get("insecure") and self
.config
.get("ca_cert"):
161 raise vimconn
.VimConnException(
162 "options insecure and ca_cert are mutually exclusive"
167 if self
.config
.get("insecure"):
170 if self
.config
.get("ca_cert"):
171 self
.verify
= self
.config
.get("ca_cert")
174 raise TypeError("url param can not be NoneType")
176 self
.persistent_info
= persistent_info
177 self
.availability_zone
= persistent_info
.get("availability_zone", None)
178 self
.session
= persistent_info
.get("session", {"reload_client": True})
179 self
.my_tenant_id
= self
.session
.get("my_tenant_id")
180 self
.nova
= self
.session
.get("nova")
181 self
.neutron
= self
.session
.get("neutron")
182 self
.cinder
= self
.session
.get("cinder")
183 self
.glance
= self
.session
.get("glance")
184 # self.glancev1 = self.session.get("glancev1")
185 self
.keystone
= self
.session
.get("keystone")
186 self
.api_version3
= self
.session
.get("api_version3")
187 self
.vim_type
= self
.config
.get("vim_type")
190 self
.vim_type
= self
.vim_type
.upper()
192 if self
.config
.get("use_internal_endpoint"):
193 self
.endpoint_type
= "internalURL"
195 self
.endpoint_type
= None
197 logging
.getLogger("urllib3").setLevel(logging
.WARNING
)
198 logging
.getLogger("keystoneauth").setLevel(logging
.WARNING
)
199 logging
.getLogger("novaclient").setLevel(logging
.WARNING
)
200 self
.logger
= logging
.getLogger("ro.vim.openstack")
202 # allow security_groups to be a list or a single string
203 if isinstance(self
.config
.get("security_groups"), str):
204 self
.config
["security_groups"] = [self
.config
["security_groups"]]
206 self
.security_groups_id
= None
208 # ###### VIO Specific Changes #########
209 if self
.vim_type
== "VIO":
210 self
.logger
= logging
.getLogger("ro.vim.vio")
213 self
.logger
.setLevel(getattr(logging
, log_level
))
215 def __getitem__(self
, index
):
216 """Get individuals parameters.
218 if index
== "project_domain_id":
219 return self
.config
.get("project_domain_id")
220 elif index
== "user_domain_id":
221 return self
.config
.get("user_domain_id")
223 return vimconn
.VimConnector
.__getitem
__(self
, index
)
225 def __setitem__(self
, index
, value
):
226 """Set individuals parameters and it is marked as dirty so to force connection reload.
228 if index
== "project_domain_id":
229 self
.config
["project_domain_id"] = value
230 elif index
== "user_domain_id":
231 self
.config
["user_domain_id"] = value
233 vimconn
.VimConnector
.__setitem
__(self
, index
, value
)
235 self
.session
["reload_client"] = True
237 def serialize(self
, value
):
238 """Serialization of python basic types.
240 In the case value is not serializable a message will be logged and a
241 simple representation of the data that cannot be converted back to
244 if isinstance(value
, str):
249 value
, Dumper
=SafeDumper
, default_flow_style
=True, width
=256
251 except yaml
.representer
.RepresenterError
:
253 "The following entity cannot be serialized in YAML:\n\n%s\n\n",
260 def _reload_connection(self
):
261 """Called before any operation, it check if credentials has changed
262 Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
264 # TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
265 if self
.session
["reload_client"]:
266 if self
.config
.get("APIversion"):
267 self
.api_version3
= (
268 self
.config
["APIversion"] == "v3.3"
269 or self
.config
["APIversion"] == "3"
271 else: # get from ending auth_url that end with v3 or with v2.0
272 self
.api_version3
= self
.url
.endswith("/v3") or self
.url
.endswith(
276 self
.session
["api_version3"] = self
.api_version3
278 if self
.api_version3
:
279 if self
.config
.get("project_domain_id") or self
.config
.get(
280 "project_domain_name"
282 project_domain_id_default
= None
284 project_domain_id_default
= "default"
286 if self
.config
.get("user_domain_id") or self
.config
.get(
289 user_domain_id_default
= None
291 user_domain_id_default
= "default"
295 password
=self
.passwd
,
296 project_name
=self
.tenant_name
,
297 project_id
=self
.tenant_id
,
298 project_domain_id
=self
.config
.get(
299 "project_domain_id", project_domain_id_default
301 user_domain_id
=self
.config
.get(
302 "user_domain_id", user_domain_id_default
304 project_domain_name
=self
.config
.get("project_domain_name"),
305 user_domain_name
=self
.config
.get("user_domain_name"),
311 password
=self
.passwd
,
312 tenant_name
=self
.tenant_name
,
313 tenant_id
=self
.tenant_id
,
316 sess
= session
.Session(auth
=auth
, verify
=self
.verify
)
317 # addedd region_name to keystone, nova, neutron and cinder to support distributed cloud for Wind River
318 # Titanium cloud and StarlingX
319 region_name
= self
.config
.get("region_name")
321 if self
.api_version3
:
322 self
.keystone
= ksClient_v3
.Client(
324 endpoint_type
=self
.endpoint_type
,
325 region_name
=region_name
,
328 self
.keystone
= ksClient_v2
.Client(
329 session
=sess
, endpoint_type
=self
.endpoint_type
332 self
.session
["keystone"] = self
.keystone
333 # In order to enable microversion functionality an explicit microversion must be specified in "config".
334 # This implementation approach is due to the warning message in
335 # https://developer.openstack.org/api-guide/compute/microversions.html
336 # where it is stated that microversion backwards compatibility is not guaranteed and clients should
337 # always require an specific microversion.
338 # To be able to use "device role tagging" functionality define "microversion: 2.32" in datacenter config
339 version
= self
.config
.get("microversion")
344 # addedd region_name to keystone, nova, neutron and cinder to support distributed cloud for Wind River
345 # Titanium cloud and StarlingX
346 self
.nova
= self
.session
["nova"] = nClient
.Client(
349 endpoint_type
=self
.endpoint_type
,
350 region_name
=region_name
,
352 self
.neutron
= self
.session
["neutron"] = neClient
.Client(
355 endpoint_type
=self
.endpoint_type
,
356 region_name
=region_name
,
358 self
.cinder
= self
.session
["cinder"] = cClient
.Client(
361 endpoint_type
=self
.endpoint_type
,
362 region_name
=region_name
,
366 self
.my_tenant_id
= self
.session
["my_tenant_id"] = sess
.get_project_id()
368 self
.logger
.error("Cannot get project_id from session", exc_info
=True)
370 if self
.endpoint_type
== "internalURL":
371 glance_service_id
= self
.keystone
.services
.list(name
="glance")[0].id
372 glance_endpoint
= self
.keystone
.endpoints
.list(
373 glance_service_id
, interface
="internal"
376 glance_endpoint
= None
378 self
.glance
= self
.session
["glance"] = glClient
.Client(
379 2, session
=sess
, endpoint
=glance_endpoint
381 # using version 1 of glance client in new_image()
382 # self.glancev1 = self.session["glancev1"] = glClient.Client("1", session=sess,
383 # endpoint=glance_endpoint)
384 self
.session
["reload_client"] = False
385 self
.persistent_info
["session"] = self
.session
386 # add availablity zone info inside self.persistent_info
387 self
._set
_availablity
_zones
()
388 self
.persistent_info
["availability_zone"] = self
.availability_zone
389 # force to get again security_groups_ids next time they are needed
390 self
.security_groups_id
= None
392 def __net_os2mano(self
, net_list_dict
):
393 """Transform the net openstack format to mano format
394 net_list_dict can be a list of dict or a single dict"""
395 if type(net_list_dict
) is dict:
396 net_list_
= (net_list_dict
,)
397 elif type(net_list_dict
) is list:
398 net_list_
= net_list_dict
400 raise TypeError("param net_list_dict must be a list or a dictionary")
401 for net
in net_list_
:
402 if net
.get("provider:network_type") == "vlan":
405 net
["type"] = "bridge"
407 def __classification_os2mano(self
, class_list_dict
):
408 """Transform the openstack format (Flow Classifier) to mano format
409 (Classification) class_list_dict can be a list of dict or a single dict
411 if isinstance(class_list_dict
, dict):
412 class_list_
= [class_list_dict
]
413 elif isinstance(class_list_dict
, list):
414 class_list_
= class_list_dict
416 raise TypeError("param class_list_dict must be a list or a dictionary")
417 for classification
in class_list_
:
418 id = classification
.pop("id")
419 name
= classification
.pop("name")
420 description
= classification
.pop("description")
421 project_id
= classification
.pop("project_id")
422 tenant_id
= classification
.pop("tenant_id")
423 original_classification
= copy
.deepcopy(classification
)
424 classification
.clear()
425 classification
["ctype"] = "legacy_flow_classifier"
426 classification
["definition"] = original_classification
427 classification
["id"] = id
428 classification
["name"] = name
429 classification
["description"] = description
430 classification
["project_id"] = project_id
431 classification
["tenant_id"] = tenant_id
433 def __sfi_os2mano(self
, sfi_list_dict
):
434 """Transform the openstack format (Port Pair) to mano format (SFI)
435 sfi_list_dict can be a list of dict or a single dict
437 if isinstance(sfi_list_dict
, dict):
438 sfi_list_
= [sfi_list_dict
]
439 elif isinstance(sfi_list_dict
, list):
440 sfi_list_
= sfi_list_dict
442 raise TypeError("param sfi_list_dict must be a list or a dictionary")
444 for sfi
in sfi_list_
:
445 sfi
["ingress_ports"] = []
446 sfi
["egress_ports"] = []
448 if sfi
.get("ingress"):
449 sfi
["ingress_ports"].append(sfi
["ingress"])
451 if sfi
.get("egress"):
452 sfi
["egress_ports"].append(sfi
["egress"])
456 params
= sfi
.get("service_function_parameters")
460 correlation
= params
.get("correlation")
465 sfi
["sfc_encap"] = sfc_encap
466 del sfi
["service_function_parameters"]
468 def __sf_os2mano(self
, sf_list_dict
):
469 """Transform the openstack format (Port Pair Group) to mano format (SF)
470 sf_list_dict can be a list of dict or a single dict
472 if isinstance(sf_list_dict
, dict):
473 sf_list_
= [sf_list_dict
]
474 elif isinstance(sf_list_dict
, list):
475 sf_list_
= sf_list_dict
477 raise TypeError("param sf_list_dict must be a list or a dictionary")
480 del sf
["port_pair_group_parameters"]
481 sf
["sfis"] = sf
["port_pairs"]
484 def __sfp_os2mano(self
, sfp_list_dict
):
485 """Transform the openstack format (Port Chain) to mano format (SFP)
486 sfp_list_dict can be a list of dict or a single dict
488 if isinstance(sfp_list_dict
, dict):
489 sfp_list_
= [sfp_list_dict
]
490 elif isinstance(sfp_list_dict
, list):
491 sfp_list_
= sfp_list_dict
493 raise TypeError("param sfp_list_dict must be a list or a dictionary")
495 for sfp
in sfp_list_
:
496 params
= sfp
.pop("chain_parameters")
500 correlation
= params
.get("correlation")
505 sfp
["sfc_encap"] = sfc_encap
506 sfp
["spi"] = sfp
.pop("chain_id")
507 sfp
["classifications"] = sfp
.pop("flow_classifiers")
508 sfp
["service_functions"] = sfp
.pop("port_pair_groups")
510 # placeholder for now; read TODO note below
511 def _validate_classification(self
, type, definition
):
512 # only legacy_flow_classifier Type is supported at this point
514 # TODO(igordcard): this method should be an abstract method of an
515 # abstract Classification class to be implemented by the specific
516 # Types. Also, abstract vimconnector should call the validation
517 # method before the implemented VIM connectors are called.
519 def _format_exception(self
, exception
):
520 """Transform a keystone, nova, neutron exception into a vimconn exception discovering the cause"""
521 message_error
= str(exception
)
527 neExceptions
.NetworkNotFoundClient
,
528 nvExceptions
.NotFound
,
529 ksExceptions
.NotFound
,
530 gl1Exceptions
.HTTPNotFound
,
533 raise vimconn
.VimConnNotFoundException(
534 type(exception
).__name
__ + ": " + message_error
540 gl1Exceptions
.HTTPException
,
541 gl1Exceptions
.CommunicationError
,
543 ksExceptions
.ConnectionError
,
544 neExceptions
.ConnectionFailed
,
547 if type(exception
).__name
__ == "SSLError":
548 tip
= " (maybe option 'insecure' must be added to the VIM)"
550 raise vimconn
.VimConnConnectionException(
551 "Invalid URL or credentials{}: {}".format(tip
, message_error
)
557 nvExceptions
.BadRequest
,
558 ksExceptions
.BadRequest
,
561 raise vimconn
.VimConnException(
562 type(exception
).__name
__ + ": " + message_error
567 nvExceptions
.ClientException
,
568 ksExceptions
.ClientException
,
569 neExceptions
.NeutronException
,
572 raise vimconn
.VimConnUnexpectedResponse(
573 type(exception
).__name
__ + ": " + message_error
575 elif isinstance(exception
, nvExceptions
.Conflict
):
576 raise vimconn
.VimConnConflictException(
577 type(exception
).__name
__ + ": " + message_error
579 elif isinstance(exception
, vimconn
.VimConnException
):
582 self
.logger
.error("General Exception " + message_error
, exc_info
=True)
584 raise vimconn
.VimConnConnectionException(
585 type(exception
).__name
__ + ": " + message_error
588 def _get_ids_from_name(self
):
590 Obtain ids from name of tenant and security_groups. Store at self .security_groups_id"
593 # get tenant_id if only tenant_name is supplied
594 self
._reload
_connection
()
596 if not self
.my_tenant_id
:
597 raise vimconn
.VimConnConnectionException(
598 "Error getting tenant information from name={} id={}".format(
599 self
.tenant_name
, self
.tenant_id
603 if self
.config
.get("security_groups") and not self
.security_groups_id
:
604 # convert from name to id
605 neutron_sg_list
= self
.neutron
.list_security_groups(
606 tenant_id
=self
.my_tenant_id
609 self
.security_groups_id
= []
610 for sg
in self
.config
.get("security_groups"):
611 for neutron_sg
in neutron_sg_list
:
612 if sg
in (neutron_sg
["id"], neutron_sg
["name"]):
613 self
.security_groups_id
.append(neutron_sg
["id"])
616 self
.security_groups_id
= None
618 raise vimconn
.VimConnConnectionException(
619 "Not found security group {} for this tenant".format(sg
)
622 def check_vim_connectivity(self
):
623 # just get network list to check connectivity and credentials
624 self
.get_network_list(filter_dict
={})
626 def get_tenant_list(self
, filter_dict
={}):
627 """Obtain tenants of VIM
628 filter_dict can contain the following keys:
629 name: filter by tenant name
630 id: filter by tenant uuid/id
632 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
634 self
.logger
.debug("Getting tenants from VIM filter: '%s'", str(filter_dict
))
637 self
._reload
_connection
()
639 if self
.api_version3
:
640 project_class_list
= self
.keystone
.projects
.list(
641 name
=filter_dict
.get("name")
644 project_class_list
= self
.keystone
.tenants
.findall(**filter_dict
)
648 for project
in project_class_list
:
649 if filter_dict
.get("id") and filter_dict
["id"] != project
.id:
652 project_list
.append(project
.to_dict())
656 ksExceptions
.ConnectionError
,
657 ksExceptions
.ClientException
,
660 self
._format
_exception
(e
)
662 def new_tenant(self
, tenant_name
, tenant_description
):
663 """Adds a new tenant to openstack VIM. Returns the tenant identifier"""
664 self
.logger
.debug("Adding a new tenant name: %s", tenant_name
)
667 self
._reload
_connection
()
669 if self
.api_version3
:
670 project
= self
.keystone
.projects
.create(
672 self
.config
.get("project_domain_id", "default"),
673 description
=tenant_description
,
677 project
= self
.keystone
.tenants
.create(tenant_name
, tenant_description
)
681 ksExceptions
.ConnectionError
,
682 ksExceptions
.ClientException
,
683 ksExceptions
.BadRequest
,
686 self
._format
_exception
(e
)
688 def delete_tenant(self
, tenant_id
):
689 """Delete a tenant from openstack VIM. Returns the old tenant identifier"""
690 self
.logger
.debug("Deleting tenant %s from VIM", tenant_id
)
693 self
._reload
_connection
()
695 if self
.api_version3
:
696 self
.keystone
.projects
.delete(tenant_id
)
698 self
.keystone
.tenants
.delete(tenant_id
)
702 ksExceptions
.ConnectionError
,
703 ksExceptions
.ClientException
,
704 ksExceptions
.NotFound
,
707 self
._format
_exception
(e
)
715 provider_network_profile
=None,
717 """Adds a tenant network to VIM
719 'net_name': name of the network
721 'bridge': overlay isolated network
722 'data': underlay E-LAN network for Passthrough and SRIOV interfaces
723 'ptp': underlay E-LINE network for Passthrough and SRIOV interfaces.
724 'ip_profile': is a dict containing the IP parameters of the network
725 'ip_version': can be "IPv4" or "IPv6" (Currently only IPv4 is implemented)
726 'subnet_address': ip_prefix_schema, that is X.X.X.X/Y
727 'gateway_address': (Optional) ip_schema, that is X.X.X.X
728 'dns_address': (Optional) comma separated list of ip_schema, e.g. X.X.X.X[,X,X,X,X]
729 'dhcp_enabled': True or False
730 'dhcp_start_address': ip_schema, first IP to grant
731 'dhcp_count': number of IPs to grant.
732 'shared': if this network can be seen/use by other tenants/organization
733 'provider_network_profile': (optional) contains {segmentation-id: vlan, network-type: vlan|vxlan,
734 physical-network: physnet-label}
735 Returns a tuple with the network identifier and created_items, or raises an exception on error
736 created_items can be None or a dictionary where this method can include key-values that will be passed to
737 the method delete_network. Can be used to store created segments, created l2gw connections, etc.
738 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
742 "Adding a new network to VIM name '%s', type '%s'", net_name
, net_type
744 # self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
749 if provider_network_profile
:
750 vlan
= provider_network_profile
.get("segmentation-id")
754 self
._reload
_connection
()
755 network_dict
= {"name": net_name
, "admin_state_up": True}
757 if net_type
in ("data", "ptp") or provider_network_profile
:
758 provider_physical_network
= None
760 if provider_network_profile
and provider_network_profile
.get(
763 provider_physical_network
= provider_network_profile
.get(
767 # provider-network must be one of the dataplane_physcial_netowrk if this is a list. If it is string
768 # or not declared, just ignore the checking
771 self
.config
.get("dataplane_physical_net"), (tuple, list)
773 and provider_physical_network
774 not in self
.config
["dataplane_physical_net"]
776 raise vimconn
.VimConnConflictException(
777 "Invalid parameter 'provider-network:physical-network' "
778 "for network creation. '{}' is not one of the declared "
779 "list at VIM_config:dataplane_physical_net".format(
780 provider_physical_network
784 # use the default dataplane_physical_net
785 if not provider_physical_network
:
786 provider_physical_network
= self
.config
.get(
787 "dataplane_physical_net"
790 # if it is non empty list, use the first value. If it is a string use the value directly
792 isinstance(provider_physical_network
, (tuple, list))
793 and provider_physical_network
795 provider_physical_network
= provider_physical_network
[0]
797 if not provider_physical_network
:
798 raise vimconn
.VimConnConflictException(
799 "missing information needed for underlay networks. Provide "
800 "'dataplane_physical_net' configuration at VIM or use the NS "
801 "instantiation parameter 'provider-network.physical-network'"
805 if not self
.config
.get("multisegment_support"):
807 "provider:physical_network"
808 ] = provider_physical_network
811 provider_network_profile
812 and "network-type" in provider_network_profile
815 "provider:network_type"
816 ] = provider_network_profile
["network-type"]
818 network_dict
["provider:network_type"] = self
.config
.get(
819 "dataplane_network_type", "vlan"
823 network_dict
["provider:segmentation_id"] = vlan
828 "provider:physical_network": "",
829 "provider:network_type": "vxlan",
831 segment_list
.append(segment1_dict
)
833 "provider:physical_network": provider_physical_network
,
834 "provider:network_type": "vlan",
838 segment2_dict
["provider:segmentation_id"] = vlan
839 elif self
.config
.get("multisegment_vlan_range"):
840 vlanID
= self
._generate
_multisegment
_vlanID
()
841 segment2_dict
["provider:segmentation_id"] = vlanID
844 # raise vimconn.VimConnConflictException(
845 # "You must provide "multisegment_vlan_range" at config dict before creating a multisegment
847 segment_list
.append(segment2_dict
)
848 network_dict
["segments"] = segment_list
850 # VIO Specific Changes. It needs a concrete VLAN
851 if self
.vim_type
== "VIO" and vlan
is None:
852 if self
.config
.get("dataplane_net_vlan_range") is None:
853 raise vimconn
.VimConnConflictException(
854 "You must provide 'dataplane_net_vlan_range' in format "
855 "[start_ID - end_ID] at VIM_config for creating underlay "
859 network_dict
["provider:segmentation_id"] = self
._generate
_vlanID
()
861 network_dict
["shared"] = shared
863 if self
.config
.get("disable_network_port_security"):
864 network_dict
["port_security_enabled"] = False
866 if self
.config
.get("neutron_availability_zone_hints"):
867 hints
= self
.config
.get("neutron_availability_zone_hints")
869 if isinstance(hints
, str):
872 network_dict
["availability_zone_hints"] = hints
874 new_net
= self
.neutron
.create_network({"network": network_dict
})
876 # create subnetwork, even if there is no profile
881 if not ip_profile
.get("subnet_address"):
882 # Fake subnet is required
883 subnet_rand
= random
.randint(0, 255)
884 ip_profile
["subnet_address"] = "192.168.{}.0/24".format(subnet_rand
)
886 if "ip_version" not in ip_profile
:
887 ip_profile
["ip_version"] = "IPv4"
890 "name": net_name
+ "-subnet",
891 "network_id": new_net
["network"]["id"],
892 "ip_version": 4 if ip_profile
["ip_version"] == "IPv4" else 6,
893 "cidr": ip_profile
["subnet_address"],
896 # Gateway should be set to None if not needed. Otherwise openstack assigns one by default
897 if ip_profile
.get("gateway_address"):
898 subnet
["gateway_ip"] = ip_profile
["gateway_address"]
900 subnet
["gateway_ip"] = None
902 if ip_profile
.get("dns_address"):
903 subnet
["dns_nameservers"] = ip_profile
["dns_address"].split(";")
905 if "dhcp_enabled" in ip_profile
:
906 subnet
["enable_dhcp"] = (
908 if ip_profile
["dhcp_enabled"] == "false"
909 or ip_profile
["dhcp_enabled"] is False
913 if ip_profile
.get("dhcp_start_address"):
914 subnet
["allocation_pools"] = []
915 subnet
["allocation_pools"].append(dict())
916 subnet
["allocation_pools"][0]["start"] = ip_profile
[
920 if ip_profile
.get("dhcp_count"):
921 # parts = ip_profile["dhcp_start_address"].split(".")
922 # ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
923 ip_int
= int(netaddr
.IPAddress(ip_profile
["dhcp_start_address"]))
924 ip_int
+= ip_profile
["dhcp_count"] - 1
925 ip_str
= str(netaddr
.IPAddress(ip_int
))
926 subnet
["allocation_pools"][0]["end"] = ip_str
928 # self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
929 self
.neutron
.create_subnet({"subnet": subnet
})
931 if net_type
== "data" and self
.config
.get("multisegment_support"):
932 if self
.config
.get("l2gw_support"):
933 l2gw_list
= self
.neutron
.list_l2_gateways().get("l2_gateways", ())
934 for l2gw
in l2gw_list
:
936 "l2_gateway_id": l2gw
["id"],
937 "network_id": new_net
["network"]["id"],
938 "segmentation_id": str(vlanID
),
940 new_l2gw_conn
= self
.neutron
.create_l2_gateway_connection(
941 {"l2_gateway_connection": l2gw_conn
}
945 + str(new_l2gw_conn
["l2_gateway_connection"]["id"])
948 return new_net
["network"]["id"], created_items
949 except Exception as e
:
950 # delete l2gw connections (if any) before deleting the network
951 for k
, v
in created_items
.items():
952 if not v
: # skip already deleted
956 k_item
, _
, k_id
= k
.partition(":")
958 if k_item
== "l2gwconn":
959 self
.neutron
.delete_l2_gateway_connection(k_id
)
960 except Exception as e2
:
962 "Error deleting l2 gateway connection: {}: {}".format(
963 type(e2
).__name
__, e2
968 self
.neutron
.delete_network(new_net
["network"]["id"])
970 self
._format
_exception
(e
)
972 def get_network_list(self
, filter_dict
={}):
973 """Obtain tenant networks of VIM
979 admin_state_up: boolean
981 Returns the network list of dictionaries
983 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
986 self
._reload
_connection
()
987 filter_dict_os
= filter_dict
.copy()
989 if self
.api_version3
and "tenant_id" in filter_dict_os
:
991 filter_dict_os
["project_id"] = filter_dict_os
.pop("tenant_id")
993 net_dict
= self
.neutron
.list_networks(**filter_dict_os
)
994 net_list
= net_dict
["networks"]
995 self
.__net
_os
2mano
(net_list
)
999 neExceptions
.ConnectionFailed
,
1000 ksExceptions
.ClientException
,
1001 neExceptions
.NeutronException
,
1004 self
._format
_exception
(e
)
1006 def get_network(self
, net_id
):
1007 """Obtain details of network from VIM
1008 Returns the network information from a network id"""
1009 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
1010 filter_dict
= {"id": net_id
}
1011 net_list
= self
.get_network_list(filter_dict
)
1013 if len(net_list
) == 0:
1014 raise vimconn
.VimConnNotFoundException(
1015 "Network '{}' not found".format(net_id
)
1017 elif len(net_list
) > 1:
1018 raise vimconn
.VimConnConflictException(
1019 "Found more than one network with this criteria"
1024 for subnet_id
in net
.get("subnets", ()):
1026 subnet
= self
.neutron
.show_subnet(subnet_id
)
1027 except Exception as e
:
1029 "osconnector.get_network(): Error getting subnet %s %s"
1032 subnet
= {"id": subnet_id
, "fault": str(e
)}
1034 subnets
.append(subnet
)
1036 net
["subnets"] = subnets
1037 net
["encapsulation"] = net
.get("provider:network_type")
1038 net
["encapsulation_type"] = net
.get("provider:network_type")
1039 net
["segmentation_id"] = net
.get("provider:segmentation_id")
1040 net
["encapsulation_id"] = net
.get("provider:segmentation_id")
1044 def delete_network(self
, net_id
, created_items
=None):
1046 Removes a tenant network from VIM and its associated elements
1047 :param net_id: VIM identifier of the network, provided by method new_network
1048 :param created_items: dictionary with extra items to be deleted. provided by method new_network
1049 Returns the network identifier or raises an exception upon error or when network is not found
1051 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
1053 if created_items
is None:
1057 self
._reload
_connection
()
1058 # delete l2gw connections (if any) before deleting the network
1059 for k
, v
in created_items
.items():
1060 if not v
: # skip already deleted
1064 k_item
, _
, k_id
= k
.partition(":")
1065 if k_item
== "l2gwconn":
1066 self
.neutron
.delete_l2_gateway_connection(k_id
)
1067 except Exception as e
:
1069 "Error deleting l2 gateway connection: {}: {}".format(
1074 # delete VM ports attached to this networks before the network
1075 ports
= self
.neutron
.list_ports(network_id
=net_id
)
1076 for p
in ports
["ports"]:
1078 self
.neutron
.delete_port(p
["id"])
1079 except Exception as e
:
1080 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
1082 self
.neutron
.delete_network(net_id
)
1086 neExceptions
.ConnectionFailed
,
1087 neExceptions
.NetworkNotFoundClient
,
1088 neExceptions
.NeutronException
,
1089 ksExceptions
.ClientException
,
1090 neExceptions
.NeutronException
,
1093 self
._format
_exception
(e
)
1095 def refresh_nets_status(self
, net_list
):
1096 """Get the status of the networks
1097 Params: the list of network identifiers
1098 Returns a dictionary with:
1099 net_id: #VIM id of this network
1100 status: #Mandatory. Text with one of:
1101 # DELETED (not found at vim)
1102 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1103 # OTHER (Vim reported other status not understood)
1104 # ERROR (VIM indicates an ERROR status)
1105 # ACTIVE, INACTIVE, DOWN (admin down),
1106 # BUILD (on building process)
1108 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1109 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1113 for net_id
in net_list
:
1117 net_vim
= self
.get_network(net_id
)
1119 if net_vim
["status"] in netStatus2manoFormat
:
1120 net
["status"] = netStatus2manoFormat
[net_vim
["status"]]
1122 net
["status"] = "OTHER"
1123 net
["error_msg"] = "VIM status reported " + net_vim
["status"]
1125 if net
["status"] == "ACTIVE" and not net_vim
["admin_state_up"]:
1126 net
["status"] = "DOWN"
1128 net
["vim_info"] = self
.serialize(net_vim
)
1130 if net_vim
.get("fault"): # TODO
1131 net
["error_msg"] = str(net_vim
["fault"])
1132 except vimconn
.VimConnNotFoundException
as e
:
1133 self
.logger
.error("Exception getting net status: %s", str(e
))
1134 net
["status"] = "DELETED"
1135 net
["error_msg"] = str(e
)
1136 except vimconn
.VimConnException
as e
:
1137 self
.logger
.error("Exception getting net status: %s", str(e
))
1138 net
["status"] = "VIM_ERROR"
1139 net
["error_msg"] = str(e
)
1140 net_dict
[net_id
] = net
1143 def get_flavor(self
, flavor_id
):
1144 """Obtain flavor details from the VIM. Returns the flavor dict details"""
1145 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
1148 self
._reload
_connection
()
1149 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
1150 # TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
1152 return flavor
.to_dict()
1154 nvExceptions
.NotFound
,
1155 nvExceptions
.ClientException
,
1156 ksExceptions
.ClientException
,
1159 self
._format
_exception
(e
)
1161 def get_flavor_id_from_data(self
, flavor_dict
):
1162 """Obtain flavor id that match the flavor description
1163 Returns the flavor_id or raises a vimconnNotFoundException
1164 flavor_dict: contains the required ram, vcpus, disk
1165 If 'use_existing_flavors' is set to True at config, the closer flavor that provides same or more ram, vcpus
1166 and disk is returned. Otherwise a flavor with exactly same ram, vcpus and disk is returned or a
1167 vimconnNotFoundException is raised
1169 exact_match
= False if self
.config
.get("use_existing_flavors") else True
1172 self
._reload
_connection
()
1173 flavor_candidate_id
= None
1174 flavor_candidate_data
= (10000, 10000, 10000)
1177 flavor_dict
["vcpus"],
1178 flavor_dict
["disk"],
1179 flavor_dict
.get("ephemeral", 0),
1180 flavor_dict
.get("swap", 0),
1183 extended
= flavor_dict
.get("extended", {})
1186 raise vimconn
.VimConnNotFoundException(
1187 "Flavor with EPA still not implemented"
1189 # if len(numas) > 1:
1190 # raise vimconn.VimConnNotFoundException("Cannot find any flavor with more than one numa")
1192 # numas = extended.get("numas")
1193 for flavor
in self
.nova
.flavors
.list():
1194 epa
= flavor
.get_keys()
1205 flavor
.swap
if isinstance(flavor
.swap
, int) else 0,
1207 if flavor_data
== flavor_target
:
1211 and flavor_target
< flavor_data
< flavor_candidate_data
1213 flavor_candidate_id
= flavor
.id
1214 flavor_candidate_data
= flavor_data
1216 if not exact_match
and flavor_candidate_id
:
1217 return flavor_candidate_id
1219 raise vimconn
.VimConnNotFoundException(
1220 "Cannot find any flavor matching '{}'".format(flavor_dict
)
1223 nvExceptions
.NotFound
,
1224 nvExceptions
.ClientException
,
1225 ksExceptions
.ClientException
,
1228 self
._format
_exception
(e
)
1231 def process_resource_quota(quota
: dict, prefix
: str, extra_specs
: dict) -> None:
1232 """Process resource quota and fill up extra_specs.
1234 quota (dict): Keeping the quota of resurces
1236 extra_specs (dict) Dict to be filled to be used during flavor creation
1239 if "limit" in quota
:
1240 extra_specs
["quota:" + prefix
+ "_limit"] = quota
["limit"]
1242 if "reserve" in quota
:
1243 extra_specs
["quota:" + prefix
+ "_reservation"] = quota
["reserve"]
1245 if "shares" in quota
:
1246 extra_specs
["quota:" + prefix
+ "_shares_level"] = "custom"
1247 extra_specs
["quota:" + prefix
+ "_shares_share"] = quota
["shares"]
1250 def process_numa_memory(
1251 numa
: dict, node_id
: Optional
[int], extra_specs
: dict
1253 """Set the memory in extra_specs.
1255 numa (dict): A dictionary which includes numa information
1256 node_id (int): ID of numa node
1257 extra_specs (dict): To be filled.
1260 if not numa
.get("memory"):
1262 memory_mb
= numa
["memory"] * 1024
1263 memory
= "hw:numa_mem.{}".format(node_id
)
1264 extra_specs
[memory
] = int(memory_mb
)
1267 def process_numa_vcpu(numa
: dict, node_id
: int, extra_specs
: dict) -> None:
1268 """Set the cpu in extra_specs.
1270 numa (dict): A dictionary which includes numa information
1271 node_id (int): ID of numa node
1272 extra_specs (dict): To be filled.
1275 if not numa
.get("vcpu"):
1278 cpu
= "hw:numa_cpus.{}".format(node_id
)
1279 vcpu
= ",".join(map(str, vcpu
))
1280 extra_specs
[cpu
] = vcpu
1283 def process_numa_paired_threads(numa
: dict, extra_specs
: dict) -> Optional
[int]:
1284 """Fill up extra_specs if numa has paired-threads.
1286 numa (dict): A dictionary which includes numa information
1287 extra_specs (dict): To be filled.
1290 threads (int) Number of virtual cpus
1293 if not numa
.get("paired-threads"):
1296 # cpu_thread_policy "require" implies that compute node must have an STM architecture
1297 threads
= numa
["paired-threads"] * 2
1298 extra_specs
["hw:cpu_thread_policy"] = "require"
1299 extra_specs
["hw:cpu_policy"] = "dedicated"
1303 def process_numa_cores(numa
: dict, extra_specs
: dict) -> Optional
[int]:
1304 """Fill up extra_specs if numa has cores.
1306 numa (dict): A dictionary which includes numa information
1307 extra_specs (dict): To be filled.
1310 cores (int) Number of virtual cpus
1313 # cpu_thread_policy "isolate" implies that the host must not have an SMT
1314 # architecture, or a non-SMT architecture will be emulated
1315 if not numa
.get("cores"):
1317 cores
= numa
["cores"]
1318 extra_specs
["hw:cpu_thread_policy"] = "isolate"
1319 extra_specs
["hw:cpu_policy"] = "dedicated"
1323 def process_numa_threads(numa
: dict, extra_specs
: dict) -> Optional
[int]:
1324 """Fill up extra_specs if numa has threads.
1326 numa (dict): A dictionary which includes numa information
1327 extra_specs (dict): To be filled.
1330 threads (int) Number of virtual cpus
1333 # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
1334 if not numa
.get("threads"):
1336 threads
= numa
["threads"]
1337 extra_specs
["hw:cpu_thread_policy"] = "prefer"
1338 extra_specs
["hw:cpu_policy"] = "dedicated"
1341 def _process_numa_parameters_of_flavor(
1342 self
, numas
: List
, extra_specs
: Dict
1344 """Process numa parameters and fill up extra_specs.
1347 numas (list): List of dictionary which includes numa information
1348 extra_specs (dict): To be filled.
1351 numa_nodes
= len(numas
)
1352 extra_specs
["hw:numa_nodes"] = str(numa_nodes
)
1353 cpu_cores
, cpu_threads
= 0, 0
1355 if self
.vim_type
== "VIO":
1356 self
.process_vio_numa_nodes(numa_nodes
, extra_specs
)
1360 node_id
= numa
["id"]
1361 # overwrite ram and vcpus
1362 # check if key "memory" is present in numa else use ram value at flavor
1363 self
.process_numa_memory(numa
, node_id
, extra_specs
)
1364 self
.process_numa_vcpu(numa
, node_id
, extra_specs
)
1366 # See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
1367 extra_specs
["hw:cpu_sockets"] = str(numa_nodes
)
1369 if "paired-threads" in numa
:
1370 threads
= self
.process_numa_paired_threads(numa
, extra_specs
)
1371 cpu_threads
+= threads
1373 elif "cores" in numa
:
1374 cores
= self
.process_numa_cores(numa
, extra_specs
)
1377 elif "threads" in numa
:
1378 threads
= self
.process_numa_threads(numa
, extra_specs
)
1379 cpu_threads
+= threads
1382 extra_specs
["hw:cpu_cores"] = str(cpu_cores
)
1384 extra_specs
["hw:cpu_threads"] = str(cpu_threads
)
1387 def process_vio_numa_nodes(numa_nodes
: int, extra_specs
: Dict
) -> None:
1388 """According to number of numa nodes, updates the extra_specs for VIO.
1392 numa_nodes (int): List keeps the numa node numbers
1393 extra_specs (dict): Extra specs dict to be updated
1396 # If there is not any numa, numas_nodes equals to 0.
1398 extra_specs
["vmware:extra_config"] = '{"numa.nodeAffinity":"0"}'
1400 # If there are several numas, we do not define specific affinity.
1401 extra_specs
["vmware:latency_sensitivity_level"] = "high"
1403 def _change_flavor_name(
1404 self
, name
: str, name_suffix
: int, flavor_data
: dict
1406 """Change the flavor name if the name already exists.
1409 name (str): Flavor name to be checked
1410 name_suffix (int): Suffix to be appended to name
1411 flavor_data (dict): Flavor dict
1414 name (str): New flavor name to be used
1418 fl
= self
.nova
.flavors
.list()
1419 fl_names
= [f
.name
for f
in fl
]
1421 while name
in fl_names
:
1423 name
= flavor_data
["name"] + "-" + str(name_suffix
)
1427 def _process_extended_config_of_flavor(
1428 self
, extended
: dict, extra_specs
: dict
1430 """Process the extended dict to fill up extra_specs.
1433 extended (dict): Keeping the extra specification of flavor
1434 extra_specs (dict) Dict to be filled to be used during flavor creation
1439 "mem-quota": "memory",
1441 "disk-io-quota": "disk_io",
1449 "PREFER_LARGE": "any",
1453 "cpu-pinning-policy": "hw:cpu_policy",
1454 "cpu-thread-pinning-policy": "hw:cpu_thread_policy",
1455 "mem-policy": "hw:numa_mempolicy",
1458 numas
= extended
.get("numas")
1460 self
._process
_numa
_parameters
_of
_flavor
(numas
, extra_specs
)
1462 for quota
, item
in quotas
.items():
1463 if quota
in extended
.keys():
1464 self
.process_resource_quota(extended
.get(quota
), item
, extra_specs
)
1466 # Set the mempage size as specified in the descriptor
1467 if extended
.get("mempage-size"):
1468 if extended
["mempage-size"] in page_sizes
.keys():
1469 extra_specs
["hw:mem_page_size"] = page_sizes
[extended
["mempage-size"]]
1471 # Normally, validations in NBI should not allow to this condition.
1473 "Invalid mempage-size %s. Will be ignored",
1474 extended
.get("mempage-size"),
1477 for policy
, hw_policy
in policies
.items():
1478 if extended
.get(policy
):
1479 extra_specs
[hw_policy
] = extended
[policy
].lower()
1482 def _get_flavor_details(flavor_data
: dict) -> Tuple
:
1483 """Returns the details of flavor
1485 flavor_data (dict): Dictionary that includes required flavor details
1488 ram, vcpus, extra_specs, extended (tuple): Main items of required flavor
1492 flavor_data
.get("ram", 64),
1493 flavor_data
.get("vcpus", 1),
1495 flavor_data
.get("extended"),
1498 def new_flavor(self
, flavor_data
: dict, change_name_if_used
: bool = True) -> str:
1499 """Adds a tenant flavor to openstack VIM.
1500 if change_name_if_used is True, it will change name in case of conflict,
1501 because it is not supported name repetition.
1504 flavor_data (dict): Flavor details to be processed
1505 change_name_if_used (bool): Change name in case of conflict
1508 flavor_id (str): flavor identifier
1511 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
1517 name
= flavor_data
["name"]
1518 while retry
< max_retries
:
1521 self
._reload
_connection
()
1523 if change_name_if_used
:
1524 name
= self
._change
_flavor
_name
(name
, name_suffix
, flavor_data
)
1526 ram
, vcpus
, extra_specs
, extended
= self
._get
_flavor
_details
(
1530 self
._process
_extended
_config
_of
_flavor
(extended
, extra_specs
)
1534 new_flavor
= self
.nova
.flavors
.create(
1538 disk
=flavor_data
.get("disk", 0),
1539 ephemeral
=flavor_data
.get("ephemeral", 0),
1540 swap
=flavor_data
.get("swap", 0),
1541 is_public
=flavor_data
.get("is_public", True),
1546 new_flavor
.set_keys(extra_specs
)
1548 return new_flavor
.id
1550 except nvExceptions
.Conflict
as e
:
1551 if change_name_if_used
and retry
< max_retries
:
1554 self
._format
_exception
(e
)
1557 ksExceptions
.ClientException
,
1558 nvExceptions
.ClientException
,
1562 self
._format
_exception
(e
)
1564 def delete_flavor(self
, flavor_id
):
1565 """Deletes a tenant flavor from openstack VIM. Returns the old flavor_id"""
1567 self
._reload
_connection
()
1568 self
.nova
.flavors
.delete(flavor_id
)
1571 # except nvExceptions.BadRequest as e:
1573 nvExceptions
.NotFound
,
1574 ksExceptions
.ClientException
,
1575 nvExceptions
.ClientException
,
1578 self
._format
_exception
(e
)
1580 def new_image(self
, image_dict
):
1582 Adds a tenant image to VIM. imge_dict is a dictionary with:
1584 disk_format: qcow2, vhd, vmdk, raw (by default), ...
1585 location: path or URI
1586 public: "yes" or "no"
1587 metadata: metadata of the image
1588 Returns the image_id
1593 while retry
< max_retries
:
1596 self
._reload
_connection
()
1598 # determine format http://docs.openstack.org/developer/glance/formats.html
1599 if "disk_format" in image_dict
:
1600 disk_format
= image_dict
["disk_format"]
1601 else: # autodiscover based on extension
1602 if image_dict
["location"].endswith(".qcow2"):
1603 disk_format
= "qcow2"
1604 elif image_dict
["location"].endswith(".vhd"):
1606 elif image_dict
["location"].endswith(".vmdk"):
1607 disk_format
= "vmdk"
1608 elif image_dict
["location"].endswith(".vdi"):
1610 elif image_dict
["location"].endswith(".iso"):
1612 elif image_dict
["location"].endswith(".aki"):
1614 elif image_dict
["location"].endswith(".ari"):
1616 elif image_dict
["location"].endswith(".ami"):
1622 "new_image: '%s' loading from '%s'",
1624 image_dict
["location"],
1626 if self
.vim_type
== "VIO":
1627 container_format
= "bare"
1628 if "container_format" in image_dict
:
1629 container_format
= image_dict
["container_format"]
1631 new_image
= self
.glance
.images
.create(
1632 name
=image_dict
["name"],
1633 container_format
=container_format
,
1634 disk_format
=disk_format
,
1637 new_image
= self
.glance
.images
.create(name
=image_dict
["name"])
1639 if image_dict
["location"].startswith("http"):
1640 # TODO there is not a method to direct download. It must be downloaded locally with requests
1641 raise vimconn
.VimConnNotImplemented("Cannot create image from URL")
1643 with
open(image_dict
["location"]) as fimage
:
1644 self
.glance
.images
.upload(new_image
.id, fimage
)
1645 # new_image = self.glancev1.images.create(name=image_dict["name"], is_public=
1646 # image_dict.get("public","yes")=="yes",
1647 # container_format="bare", data=fimage, disk_format=disk_format)
1649 metadata_to_load
= image_dict
.get("metadata")
1651 # TODO location is a reserved word for current openstack versions. fixed for VIO please check
1653 if self
.vim_type
== "VIO":
1654 metadata_to_load
["upload_location"] = image_dict
["location"]
1656 metadata_to_load
["location"] = image_dict
["location"]
1658 self
.glance
.images
.update(new_image
.id, **metadata_to_load
)
1662 nvExceptions
.Conflict
,
1663 ksExceptions
.ClientException
,
1664 nvExceptions
.ClientException
,
1666 self
._format
_exception
(e
)
1669 gl1Exceptions
.HTTPException
,
1670 gl1Exceptions
.CommunicationError
,
1673 if retry
== max_retries
:
1676 self
._format
_exception
(e
)
1677 except IOError as e
: # can not open the file
1678 raise vimconn
.VimConnConnectionException(
1679 "{}: {} for {}".format(type(e
).__name
__, e
, image_dict
["location"]),
1680 http_code
=vimconn
.HTTP_Bad_Request
,
1683 def delete_image(self
, image_id
):
1684 """Deletes a tenant image from openstack VIM. Returns the old id"""
1686 self
._reload
_connection
()
1687 self
.glance
.images
.delete(image_id
)
1691 nvExceptions
.NotFound
,
1692 ksExceptions
.ClientException
,
1693 nvExceptions
.ClientException
,
1694 gl1Exceptions
.CommunicationError
,
1695 gl1Exceptions
.HTTPNotFound
,
1697 ) as e
: # TODO remove
1698 self
._format
_exception
(e
)
1700 def get_image_id_from_path(self
, path
):
1701 """Get the image id from image path in the VIM database. Returns the image_id"""
1703 self
._reload
_connection
()
1704 images
= self
.glance
.images
.list()
1706 for image
in images
:
1707 if image
.metadata
.get("location") == path
:
1710 raise vimconn
.VimConnNotFoundException(
1711 "image with location '{}' not found".format(path
)
1714 ksExceptions
.ClientException
,
1715 nvExceptions
.ClientException
,
1716 gl1Exceptions
.CommunicationError
,
1719 self
._format
_exception
(e
)
1721 def get_image_list(self
, filter_dict
={}):
1722 """Obtain tenant images from VIM
1726 checksum: image checksum
1727 Returns the image list of dictionaries:
1728 [{<the fields at Filter_dict plus some VIM specific>}, ...]
1731 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
1734 self
._reload
_connection
()
1735 # filter_dict_os = filter_dict.copy()
1736 # First we filter by the available filter fields: name, id. The others are removed.
1737 image_list
= self
.glance
.images
.list()
1740 for image
in image_list
:
1742 if filter_dict
.get("name") and image
["name"] != filter_dict
["name"]:
1745 if filter_dict
.get("id") and image
["id"] != filter_dict
["id"]:
1749 filter_dict
.get("checksum")
1750 and image
["checksum"] != filter_dict
["checksum"]
1754 filtered_list
.append(image
.copy())
1755 except gl1Exceptions
.HTTPNotFound
:
1758 return filtered_list
1760 ksExceptions
.ClientException
,
1761 nvExceptions
.ClientException
,
1762 gl1Exceptions
.CommunicationError
,
1765 self
._format
_exception
(e
)
1767 def __wait_for_vm(self
, vm_id
, status
):
1768 """wait until vm is in the desired status and return True.
1769 If the VM gets in ERROR status, return false.
1770 If the timeout is reached generate an exception"""
1772 while elapsed_time
< server_timeout
:
1773 vm_status
= self
.nova
.servers
.get(vm_id
).status
1775 if vm_status
== status
:
1778 if vm_status
== "ERROR":
1784 # if we exceeded the timeout rollback
1785 if elapsed_time
>= server_timeout
:
1786 raise vimconn
.VimConnException(
1787 "Timeout waiting for instance " + vm_id
+ " to get " + status
,
1788 http_code
=vimconn
.HTTP_Request_Timeout
,
1791 def _get_openstack_availablity_zones(self
):
1793 Get from openstack availability zones available
1797 openstack_availability_zone
= self
.nova
.availability_zones
.list()
1798 openstack_availability_zone
= [
1800 for zone
in openstack_availability_zone
1801 if zone
.zoneName
!= "internal"
1804 return openstack_availability_zone
1808 def _set_availablity_zones(self
):
1810 Set vim availablity zone
1813 if "availability_zone" in self
.config
:
1814 vim_availability_zones
= self
.config
.get("availability_zone")
1816 if isinstance(vim_availability_zones
, str):
1817 self
.availability_zone
= [vim_availability_zones
]
1818 elif isinstance(vim_availability_zones
, list):
1819 self
.availability_zone
= vim_availability_zones
1821 self
.availability_zone
= self
._get
_openstack
_availablity
_zones
()
1823 def _get_vm_availability_zone(
1824 self
, availability_zone_index
, availability_zone_list
1827 Return thge availability zone to be used by the created VM.
1828 :return: The VIM availability zone to be used or None
1830 if availability_zone_index
is None:
1831 if not self
.config
.get("availability_zone"):
1833 elif isinstance(self
.config
.get("availability_zone"), str):
1834 return self
.config
["availability_zone"]
1836 # TODO consider using a different parameter at config for default AV and AV list match
1837 return self
.config
["availability_zone"][0]
1839 vim_availability_zones
= self
.availability_zone
1840 # check if VIM offer enough availability zones describe in the VNFD
1841 if vim_availability_zones
and len(availability_zone_list
) <= len(
1842 vim_availability_zones
1844 # check if all the names of NFV AV match VIM AV names
1845 match_by_index
= False
1846 for av
in availability_zone_list
:
1847 if av
not in vim_availability_zones
:
1848 match_by_index
= True
1852 return vim_availability_zones
[availability_zone_index
]
1854 return availability_zone_list
[availability_zone_index
]
1856 raise vimconn
.VimConnConflictException(
1857 "No enough availability zones at VIM for this deployment"
1860 def _prepare_port_dict_security_groups(self
, net
: dict, port_dict
: dict) -> None:
1861 """Fill up the security_groups in the port_dict.
1864 net (dict): Network details
1865 port_dict (dict): Port details
1869 self
.config
.get("security_groups")
1870 and net
.get("port_security") is not False
1871 and not self
.config
.get("no_port_security_extension")
1873 if not self
.security_groups_id
:
1874 self
._get
_ids
_from
_name
()
1876 port_dict
["security_groups"] = self
.security_groups_id
1878 def _prepare_port_dict_binding(self
, net
: dict, port_dict
: dict) -> None:
1879 """Fill up the network binding depending on network type in the port_dict.
1882 net (dict): Network details
1883 port_dict (dict): Port details
1886 if not net
.get("type"):
1887 raise vimconn
.VimConnException("Type is missing in the network details.")
1889 if net
["type"] == "virtual":
1893 elif net
["type"] == "VF" or net
["type"] == "SR-IOV":
1894 port_dict
["binding:vnic_type"] = "direct"
1896 # VIO specific Changes
1897 if self
.vim_type
== "VIO":
1898 # Need to create port with port_security_enabled = False and no-security-groups
1899 port_dict
["port_security_enabled"] = False
1900 port_dict
["provider_security_groups"] = []
1901 port_dict
["security_groups"] = []
1904 # For PT PCI-PASSTHROUGH
1905 port_dict
["binding:vnic_type"] = "direct-physical"
1908 def _set_fixed_ip(new_port
: dict, net
: dict) -> None:
1909 """Set the "ip" parameter in net dictionary.
1912 new_port (dict): New created port
1913 net (dict): Network details
1916 fixed_ips
= new_port
["port"].get("fixed_ips")
1919 net
["ip"] = fixed_ips
[0].get("ip_address")
1924 def _prepare_port_dict_mac_ip_addr(net
: dict, port_dict
: dict) -> None:
1925 """Fill up the mac_address and fixed_ips in port_dict.
1928 net (dict): Network details
1929 port_dict (dict): Port details
1932 if net
.get("mac_address"):
1933 port_dict
["mac_address"] = net
["mac_address"]
1935 if net
.get("ip_address"):
1936 port_dict
["fixed_ips"] = [{"ip_address": net
["ip_address"]}]
1937 # TODO add "subnet_id": <subnet_id>
1939 def _create_new_port(self
, port_dict
: dict, created_items
: dict, net
: dict) -> Dict
:
1940 """Create new port using neutron.
1943 port_dict (dict): Port details
1944 created_items (dict): All created items
1945 net (dict): Network details
1948 new_port (dict): New created port
1951 new_port
= self
.neutron
.create_port({"port": port_dict
})
1952 created_items
["port:" + str(new_port
["port"]["id"])] = True
1953 net
["mac_adress"] = new_port
["port"]["mac_address"]
1954 net
["vim_id"] = new_port
["port"]["id"]
1959 self
, net
: dict, name
: str, created_items
: dict
1960 ) -> Tuple
[dict, dict]:
1961 """Create port using net details.
1964 net (dict): Network details
1965 name (str): Name to be used as network name if net dict does not include name
1966 created_items (dict): All created items
1969 new_port, port New created port, port dictionary
1974 "network_id": net
["net_id"],
1975 "name": net
.get("name"),
1976 "admin_state_up": True,
1979 if not port_dict
["name"]:
1980 port_dict
["name"] = name
1982 self
._prepare
_port
_dict
_security
_groups
(net
, port_dict
)
1984 self
._prepare
_port
_dict
_binding
(net
, port_dict
)
1986 vimconnector
._prepare
_port
_dict
_mac
_ip
_addr
(net
, port_dict
)
1988 new_port
= self
._create
_new
_port
(port_dict
, created_items
, net
)
1990 vimconnector
._set
_fixed
_ip
(new_port
, net
)
1992 port
= {"port-id": new_port
["port"]["id"]}
1994 if float(self
.nova
.api_version
.get_string()) >= 2.32:
1995 port
["tag"] = new_port
["port"]["name"]
1997 return new_port
, port
1999 def _prepare_network_for_vminstance(
2003 created_items
: dict,
2005 external_network
: list,
2006 no_secured_ports
: list,
2008 """Create port and fill up net dictionary for new VM instance creation.
2011 name (str): Name of network
2012 net_list (list): List of networks
2013 created_items (dict): All created items belongs to a VM
2014 net_list_vim (list): List of ports
2015 external_network (list): List of external-networks
2016 no_secured_ports (list): Port security disabled ports
2019 self
._reload
_connection
()
2021 for net
in net_list
:
2022 # Skip non-connected iface
2023 if not net
.get("net_id"):
2026 new_port
, port
= self
._create
_port
(net
, name
, created_items
)
2028 net_list_vim
.append(port
)
2030 if net
.get("floating_ip", False):
2031 net
["exit_on_floating_ip_error"] = True
2032 external_network
.append(net
)
2034 elif net
["use"] == "mgmt" and self
.config
.get("use_floating_ip"):
2035 net
["exit_on_floating_ip_error"] = False
2036 external_network
.append(net
)
2037 net
["floating_ip"] = self
.config
.get("use_floating_ip")
2039 # If port security is disabled when the port has not yet been attached to the VM, then all vm traffic
2040 # is dropped. As a workaround we wait until the VM is active and then disable the port-security
2041 if net
.get("port_security") is False and not self
.config
.get(
2042 "no_port_security_extension"
2044 no_secured_ports
.append(
2046 new_port
["port"]["id"],
2047 net
.get("port_security_disable_strategy"),
2051 def _prepare_persistent_root_volumes(
2056 base_disk_index
: int,
2057 block_device_mapping
: dict,
2058 existing_vim_volumes
: list,
2059 created_items
: dict,
2061 """Prepare persistent root volumes for new VM instance.
2064 name (str): Name of VM instance
2065 vm_av_zone (list): List of availability zones
2066 disk (dict): Disk details
2067 base_disk_index (int): Disk index
2068 block_device_mapping (dict): Block device details
2069 existing_vim_volumes (list): Existing disk details
2070 created_items (dict): All created items belongs to VM
2073 boot_volume_id (str): ID of boot volume
2076 # Disk may include only vim_volume_id or only vim_id."
2077 # Use existing persistent root volume finding with volume_id or vim_id
2078 key_id
= "vim_volume_id" if "vim_volume_id" in disk
.keys() else "vim_id"
2080 if disk
.get(key_id
):
2081 block_device_mapping
["vd" + chr(base_disk_index
)] = disk
[key_id
]
2082 existing_vim_volumes
.append({"id": disk
[key_id
]})
2085 # Create persistent root volume
2086 volume
= self
.cinder
.volumes
.create(
2088 name
=name
+ "vd" + chr(base_disk_index
),
2089 imageRef
=disk
["image_id"],
2090 # Make sure volume is in the same AZ as the VM to be attached to
2091 availability_zone
=vm_av_zone
,
2093 boot_volume_id
= volume
.id
2094 self
.update_block_device_mapping(
2096 block_device_mapping
=block_device_mapping
,
2097 base_disk_index
=base_disk_index
,
2099 created_items
=created_items
,
2102 return boot_volume_id
2105 def update_block_device_mapping(
2107 block_device_mapping
: dict,
2108 base_disk_index
: int,
2110 created_items
: dict,
2112 """Add volume information to block device mapping dict.
2114 volume (object): Created volume object
2115 block_device_mapping (dict): Block device details
2116 base_disk_index (int): Disk index
2117 disk (dict): Disk details
2118 created_items (dict): All created items belongs to VM
2121 raise vimconn
.VimConnException("Volume is empty.")
2123 if not hasattr(volume
, "id"):
2124 raise vimconn
.VimConnException(
2125 "Created volume is not valid, does not have id attribute."
2128 volume_txt
= "volume:" + str(volume
.id)
2129 if disk
.get("keep"):
2130 volume_txt
+= ":keep"
2131 created_items
[volume_txt
] = True
2132 block_device_mapping
["vd" + chr(base_disk_index
)] = volume
.id
2134 def _prepare_non_root_persistent_volumes(
2139 block_device_mapping
: dict,
2140 base_disk_index
: int,
2141 existing_vim_volumes
: list,
2142 created_items
: dict,
2144 """Prepare persistent volumes for new VM instance.
2147 name (str): Name of VM instance
2148 disk (dict): Disk details
2149 vm_av_zone (list): List of availability zones
2150 block_device_mapping (dict): Block device details
2151 base_disk_index (int): Disk index
2152 existing_vim_volumes (list): Existing disk details
2153 created_items (dict): All created items belongs to VM
2155 # Non-root persistent volumes
2156 # Disk may include only vim_volume_id or only vim_id."
2157 key_id
= "vim_volume_id" if "vim_volume_id" in disk
.keys() else "vim_id"
2159 if disk
.get(key_id
):
2160 # Use existing persistent volume
2161 block_device_mapping
["vd" + chr(base_disk_index
)] = disk
[key_id
]
2162 existing_vim_volumes
.append({"id": disk
[key_id
]})
2165 # Create persistent volume
2166 volume
= self
.cinder
.volumes
.create(
2168 name
=name
+ "vd" + chr(base_disk_index
),
2169 # Make sure volume is in the same AZ as the VM to be attached to
2170 availability_zone
=vm_av_zone
,
2172 self
.update_block_device_mapping(
2174 block_device_mapping
=block_device_mapping
,
2175 base_disk_index
=base_disk_index
,
2177 created_items
=created_items
,
2180 def _wait_for_created_volumes_availability(
2181 self
, elapsed_time
: int, created_items
: dict
2183 """Wait till created volumes become available.
2186 elapsed_time (int): Passed time while waiting
2187 created_items (dict): All created items belongs to VM
2190 elapsed_time (int): Time spent while waiting
2194 while elapsed_time
< volume_timeout
:
2195 for created_item
in created_items
:
2197 created_item
.split(":")[0],
2198 created_item
.split(":")[1],
2201 if self
.cinder
.volumes
.get(volume_id
).status
!= "available":
2204 # All ready: break from while
2212 def _wait_for_existing_volumes_availability(
2213 self
, elapsed_time
: int, existing_vim_volumes
: list
2215 """Wait till existing volumes become available.
2218 elapsed_time (int): Passed time while waiting
2219 existing_vim_volumes (list): Existing volume details
2222 elapsed_time (int): Time spent while waiting
2226 while elapsed_time
< volume_timeout
:
2227 for volume
in existing_vim_volumes
:
2228 if self
.cinder
.volumes
.get(volume
["id"]).status
!= "available":
2230 else: # all ready: break from while
2238 def _prepare_disk_for_vminstance(
2241 existing_vim_volumes
: list,
2242 created_items
: dict,
2244 block_device_mapping
: dict,
2245 disk_list
: list = None,
2247 """Prepare all volumes for new VM instance.
2250 name (str): Name of Instance
2251 existing_vim_volumes (list): List of existing volumes
2252 created_items (dict): All created items belongs to VM
2253 vm_av_zone (list): VM availability zone
2254 block_device_mapping (dict): Block devices to be attached to VM
2255 disk_list (list): List of disks
2258 # Create additional volumes in case these are present in disk_list
2259 base_disk_index
= ord("b")
2260 boot_volume_id
= None
2263 for disk
in disk_list
:
2264 if "image_id" in disk
:
2265 # Root persistent volume
2266 base_disk_index
= ord("a")
2267 boot_volume_id
= self
._prepare
_persistent
_root
_volumes
(
2269 vm_av_zone
=vm_av_zone
,
2271 base_disk_index
=base_disk_index
,
2272 block_device_mapping
=block_device_mapping
,
2273 existing_vim_volumes
=existing_vim_volumes
,
2274 created_items
=created_items
,
2277 # Non-root persistent volume
2278 self
._prepare
_non
_root
_persistent
_volumes
(
2281 vm_av_zone
=vm_av_zone
,
2282 block_device_mapping
=block_device_mapping
,
2283 base_disk_index
=base_disk_index
,
2284 existing_vim_volumes
=existing_vim_volumes
,
2285 created_items
=created_items
,
2287 base_disk_index
+= 1
2289 # Wait until created volumes are with status available
2290 elapsed_time
= self
._wait
_for
_created
_volumes
_availability
(
2291 elapsed_time
, created_items
2293 # Wait until existing volumes in vim are with status available
2294 elapsed_time
= self
._wait
_for
_existing
_volumes
_availability
(
2295 elapsed_time
, existing_vim_volumes
2297 # If we exceeded the timeout rollback
2298 if elapsed_time
>= volume_timeout
:
2299 raise vimconn
.VimConnException(
2300 "Timeout creating volumes for instance " + name
,
2301 http_code
=vimconn
.HTTP_Request_Timeout
,
2304 self
.cinder
.volumes
.set_bootable(boot_volume_id
, True)
2306 def _find_the_external_network_for_floating_ip(self
):
2307 """Get the external network ip in order to create floating IP.
2310 pool_id (str): External network pool ID
2314 # Find the external network
2315 external_nets
= list()
2317 for net
in self
.neutron
.list_networks()["networks"]:
2318 if net
["router:external"]:
2319 external_nets
.append(net
)
2321 if len(external_nets
) == 0:
2322 raise vimconn
.VimConnException(
2323 "Cannot create floating_ip automatically since "
2324 "no external network is present",
2325 http_code
=vimconn
.HTTP_Conflict
,
2328 if len(external_nets
) > 1:
2329 raise vimconn
.VimConnException(
2330 "Cannot create floating_ip automatically since "
2331 "multiple external networks are present",
2332 http_code
=vimconn
.HTTP_Conflict
,
2336 return external_nets
[0].get("id")
2338 def _neutron_create_float_ip(self
, param
: dict, created_items
: dict) -> None:
2339 """Trigger neutron to create a new floating IP using external network ID.
2342 param (dict): Input parameters to create a floating IP
2343 created_items (dict): All created items belongs to new VM instance
2350 self
.logger
.debug("Creating floating IP")
2351 new_floating_ip
= self
.neutron
.create_floatingip(param
)
2352 free_floating_ip
= new_floating_ip
["floatingip"]["id"]
2353 created_items
["floating_ip:" + str(free_floating_ip
)] = True
2355 except Exception as e
:
2356 raise vimconn
.VimConnException(
2357 type(e
).__name
__ + ": Cannot create new floating_ip " + str(e
),
2358 http_code
=vimconn
.HTTP_Conflict
,
2361 def _create_floating_ip(
2362 self
, floating_network
: dict, server
: object, created_items
: dict
2364 """Get the available Pool ID and create a new floating IP.
2367 floating_network (dict): Dict including external network ID
2368 server (object): Server object
2369 created_items (dict): All created items belongs to new VM instance
2373 # Pool_id is available
2375 isinstance(floating_network
["floating_ip"], str)
2376 and floating_network
["floating_ip"].lower() != "true"
2378 pool_id
= floating_network
["floating_ip"]
2382 pool_id
= self
._find
_the
_external
_network
_for
_floating
_ip
()
2386 "floating_network_id": pool_id
,
2387 "tenant_id": server
.tenant_id
,
2391 self
._neutron
_create
_float
_ip
(param
, created_items
)
2393 def _find_floating_ip(
2397 floating_network
: dict,
2399 """Find the available free floating IPs if there are.
2402 server (object): Server object
2403 floating_ips (list): List of floating IPs
2404 floating_network (dict): Details of floating network such as ID
2407 free_floating_ip (str): Free floating ip address
2410 for fip
in floating_ips
:
2411 if fip
.get("port_id") or fip
.get("tenant_id") != server
.tenant_id
:
2414 if isinstance(floating_network
["floating_ip"], str):
2415 if fip
.get("floating_network_id") != floating_network
["floating_ip"]:
2420 def _assign_floating_ip(
2421 self
, free_floating_ip
: str, floating_network
: dict
2423 """Assign the free floating ip address to port.
2426 free_floating_ip (str): Floating IP to be assigned
2427 floating_network (dict): ID of floating network
2430 fip (dict) (dict): Floating ip details
2433 # The vim_id key contains the neutron.port_id
2434 self
.neutron
.update_floatingip(
2436 {"floatingip": {"port_id": floating_network
["vim_id"]}},
2438 # For race condition ensure not re-assigned to other VM after 5 seconds
2441 return self
.neutron
.show_floatingip(free_floating_ip
)
2443 def _get_free_floating_ip(
2444 self
, server
: object, floating_network
: dict
2446 """Get the free floating IP address.
2449 server (object): Server Object
2450 floating_network (dict): Floating network details
2453 free_floating_ip (str): Free floating ip addr
2457 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
2460 random
.shuffle(floating_ips
)
2462 return self
._find
_floating
_ip
(server
, floating_ips
, floating_network
)
2464 def _prepare_external_network_for_vminstance(
2466 external_network
: list,
2468 created_items
: dict,
2469 vm_start_time
: float,
2471 """Assign floating IP address for VM instance.
2474 external_network (list): ID of External network
2475 server (object): Server Object
2476 created_items (dict): All created items belongs to new VM instance
2477 vm_start_time (float): Time as a floating point number expressed in seconds since the epoch, in UTC
2483 for floating_network
in external_network
:
2486 floating_ip_retries
= 3
2487 # In case of RO in HA there can be conflicts, two RO trying to assign same floating IP, so retry
2490 free_floating_ip
= self
._get
_free
_floating
_ip
(
2491 server
, floating_network
2494 if not free_floating_ip
:
2495 self
._create
_floating
_ip
(
2496 floating_network
, server
, created_items
2500 # For race condition ensure not already assigned
2501 fip
= self
.neutron
.show_floatingip(free_floating_ip
)
2503 if fip
["floatingip"].get("port_id"):
2506 # Assign floating ip
2507 fip
= self
._assign
_floating
_ip
(
2508 free_floating_ip
, floating_network
2511 if fip
["floatingip"]["port_id"] != floating_network
["vim_id"]:
2512 self
.logger
.warning(
2513 "floating_ip {} re-assigned to other port".format(
2520 "Assigned floating_ip {} to VM {}".format(
2521 free_floating_ip
, server
.id
2527 except Exception as e
:
2528 # Openstack need some time after VM creation to assign an IP. So retry if fails
2529 vm_status
= self
.nova
.servers
.get(server
.id).status
2531 if vm_status
not in ("ACTIVE", "ERROR"):
2532 if time
.time() - vm_start_time
< server_timeout
:
2535 elif floating_ip_retries
> 0:
2536 floating_ip_retries
-= 1
2539 raise vimconn
.VimConnException(
2540 "Cannot create floating_ip: {} {}".format(
2543 http_code
=vimconn
.HTTP_Conflict
,
2546 except Exception as e
:
2547 if not floating_network
["exit_on_floating_ip_error"]:
2548 self
.logger
.error("Cannot create floating_ip. %s", str(e
))
2553 def _update_port_security_for_vminstance(
2555 no_secured_ports
: list,
2558 """Updates the port security according to no_secured_ports list.
2561 no_secured_ports (list): List of ports that security will be disabled
2562 server (object): Server Object
2568 # Wait until the VM is active and then disable the port-security
2569 if no_secured_ports
:
2570 self
.__wait
_for
_vm
(server
.id, "ACTIVE")
2572 for port
in no_secured_ports
:
2574 "port": {"port_security_enabled": False, "security_groups": None}
2577 if port
[1] == "allow-address-pairs":
2579 "port": {"allowed_address_pairs": [{"ip_address": "0.0.0.0/0"}]}
2583 self
.neutron
.update_port(port
[0], port_update
)
2586 raise vimconn
.VimConnException(
2587 "It was not possible to disable port security for port {}".format(
2599 affinity_group_list
: list,
2603 availability_zone_index
=None,
2604 availability_zone_list
=None,
2606 """Adds a VM instance to VIM.
2609 name (str): name of VM
2610 description (str): description
2611 start (bool): indicates if VM must start or boot in pause mode. Ignored
2612 image_id (str) image uuid
2613 flavor_id (str) flavor uuid
2614 affinity_group_list (list): list of affinity groups, each one is a dictionary.Ignore if empty.
2615 net_list (list): list of interfaces, each one is a dictionary with:
2616 name: name of network
2617 net_id: network uuid to connect
2618 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
2619 model: interface model, ignored #TODO
2620 mac_address: used for SR-IOV ifaces #TODO for other types
2621 use: 'data', 'bridge', 'mgmt'
2622 type: 'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
2623 vim_id: filled/added by this function
2624 floating_ip: True/False (or it can be None)
2625 port_security: True/False
2626 cloud_config (dict): (optional) dictionary with:
2627 key-pairs: (optional) list of strings with the public key to be inserted to the default user
2628 users: (optional) list of users to be inserted, each item is a dict with:
2629 name: (mandatory) user name,
2630 key-pairs: (optional) list of strings with the public key to be inserted to the user
2631 user-data: (optional) string is a text script to be passed directly to cloud-init
2632 config-files: (optional). List of files to be transferred. Each item is a dict with:
2633 dest: (mandatory) string with the destination absolute path
2634 encoding: (optional, by default text). Can be one of:
2635 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
2636 content : (mandatory) string with the content of the file
2637 permissions: (optional) string with file permissions, typically octal notation '0644'
2638 owner: (optional) file owner, string with the format 'owner:group'
2639 boot-data-drive: boolean to indicate if user-data must be passed using a boot drive (hard disk)
2640 disk_list: (optional) list with additional disks to the VM. Each item is a dict with:
2641 image_id: (optional). VIM id of an existing image. If not provided an empty disk must be mounted
2642 size: (mandatory) string with the size of the disk in GB
2643 vim_id: (optional) should use this existing volume id
2644 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
2645 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
2646 availability_zone_index is None
2647 #TODO ip, security groups
2650 A tuple with the instance identifier and created_items or raises an exception on error
2651 created_items can be None or a dictionary where this method can include key-values that will be passed to
2652 the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
2653 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
2658 "new_vminstance input: image='%s' flavor='%s' nics='%s'",
2668 # list of external networks to be connected to instance, later on used to create floating_ip
2669 external_network
= []
2670 # List of ports with port-security disabled
2671 no_secured_ports
= []
2672 block_device_mapping
= {}
2673 existing_vim_volumes
= []
2674 server_group_id
= None
2675 scheduller_hints
= {}
2677 # Check the Openstack Connection
2678 self
._reload
_connection
()
2680 # Prepare network list
2681 self
._prepare
_network
_for
_vminstance
(
2684 created_items
=created_items
,
2685 net_list_vim
=net_list_vim
,
2686 external_network
=external_network
,
2687 no_secured_ports
=no_secured_ports
,
2691 config_drive
, userdata
= self
._create
_user
_data
(cloud_config
)
2693 # Get availability Zone
2694 vm_av_zone
= self
._get
_vm
_availability
_zone
(
2695 availability_zone_index
, availability_zone_list
2700 self
._prepare
_disk
_for
_vminstance
(
2702 existing_vim_volumes
=existing_vim_volumes
,
2703 created_items
=created_items
,
2704 vm_av_zone
=vm_av_zone
,
2705 block_device_mapping
=block_device_mapping
,
2706 disk_list
=disk_list
,
2709 if affinity_group_list
:
2710 # Only first id on the list will be used. Openstack restriction
2711 server_group_id
= affinity_group_list
[0]["affinity_group_id"]
2712 scheduller_hints
["group"] = server_group_id
2715 "nova.servers.create({}, {}, {}, nics={}, security_groups={}, "
2716 "availability_zone={}, key_name={}, userdata={}, config_drive={}, "
2717 "block_device_mapping={}, server_group={})".format(
2722 self
.config
.get("security_groups"),
2724 self
.config
.get("keypair"),
2727 block_device_mapping
,
2733 server
= self
.nova
.servers
.create(
2738 security_groups
=self
.config
.get("security_groups"),
2739 # TODO remove security_groups in future versions. Already at neutron port
2740 availability_zone
=vm_av_zone
,
2741 key_name
=self
.config
.get("keypair"),
2743 config_drive
=config_drive
,
2744 block_device_mapping
=block_device_mapping
,
2745 scheduler_hints
=scheduller_hints
,
2748 vm_start_time
= time
.time()
2750 self
._update
_port
_security
_for
_vminstance
(no_secured_ports
, server
)
2752 self
._prepare
_external
_network
_for
_vminstance
(
2753 external_network
=external_network
,
2755 created_items
=created_items
,
2756 vm_start_time
=vm_start_time
,
2759 return server
.id, created_items
2761 except Exception as e
:
2764 server_id
= server
.id
2767 created_items
= self
.remove_keep_tag_from_persistent_volumes(
2771 self
.delete_vminstance(server_id
, created_items
)
2773 except Exception as e2
:
2774 self
.logger
.error("new_vminstance rollback fail {}".format(e2
))
2776 self
._format
_exception
(e
)
2779 def remove_keep_tag_from_persistent_volumes(created_items
: Dict
) -> Dict
:
2780 """Removes the keep flag from persistent volumes. So, those volumes could be removed.
2783 created_items (dict): All created items belongs to VM
2786 updated_created_items (dict): Dict which does not include keep flag for volumes.
2790 key
.replace(":keep", ""): value
for (key
, value
) in created_items
.items()
2793 def get_vminstance(self
, vm_id
):
2794 """Returns the VM instance information from VIM"""
2795 # self.logger.debug("Getting VM from VIM")
2797 self
._reload
_connection
()
2798 server
= self
.nova
.servers
.find(id=vm_id
)
2799 # TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
2801 return server
.to_dict()
2803 ksExceptions
.ClientException
,
2804 nvExceptions
.ClientException
,
2805 nvExceptions
.NotFound
,
2808 self
._format
_exception
(e
)
2810 def get_vminstance_console(self
, vm_id
, console_type
="vnc"):
2812 Get a console for the virtual machine
2814 vm_id: uuid of the VM
2815 console_type, can be:
2816 "novnc" (by default), "xvpvnc" for VNC types,
2817 "rdp-html5" for RDP types, "spice-html5" for SPICE types
2818 Returns dict with the console parameters:
2819 protocol: ssh, ftp, http, https, ...
2820 server: usually ip address
2821 port: the http, ssh, ... port
2822 suffix: extra text, e.g. the http path and query string
2824 self
.logger
.debug("Getting VM CONSOLE from VIM")
2827 self
._reload
_connection
()
2828 server
= self
.nova
.servers
.find(id=vm_id
)
2830 if console_type
is None or console_type
== "novnc":
2831 console_dict
= server
.get_vnc_console("novnc")
2832 elif console_type
== "xvpvnc":
2833 console_dict
= server
.get_vnc_console(console_type
)
2834 elif console_type
== "rdp-html5":
2835 console_dict
= server
.get_rdp_console(console_type
)
2836 elif console_type
== "spice-html5":
2837 console_dict
= server
.get_spice_console(console_type
)
2839 raise vimconn
.VimConnException(
2840 "console type '{}' not allowed".format(console_type
),
2841 http_code
=vimconn
.HTTP_Bad_Request
,
2844 console_dict1
= console_dict
.get("console")
2847 console_url
= console_dict1
.get("url")
2851 protocol_index
= console_url
.find("//")
2853 console_url
[protocol_index
+ 2 :].find("/") + protocol_index
+ 2
2856 console_url
[protocol_index
+ 2 : suffix_index
].find(":")
2861 if protocol_index
< 0 or port_index
< 0 or suffix_index
< 0:
2863 -vimconn
.HTTP_Internal_Server_Error
,
2864 "Unexpected response from VIM",
2868 "protocol": console_url
[0:protocol_index
],
2869 "server": console_url
[protocol_index
+ 2 : port_index
],
2870 "port": console_url
[port_index
:suffix_index
],
2871 "suffix": console_url
[suffix_index
+ 1 :],
2876 raise vimconn
.VimConnUnexpectedResponse("Unexpected response from VIM")
2878 nvExceptions
.NotFound
,
2879 ksExceptions
.ClientException
,
2880 nvExceptions
.ClientException
,
2881 nvExceptions
.BadRequest
,
2884 self
._format
_exception
(e
)
2886 def _delete_ports_by_id_wth_neutron(self
, k_id
: str) -> None:
2887 """Neutron delete ports by id.
2889 k_id (str): Port id in the VIM
2892 port_dict
= self
.neutron
.list_ports()
2893 existing_ports
= [port
["id"] for port
in port_dict
["ports"] if port_dict
]
2895 if k_id
in existing_ports
:
2896 self
.neutron
.delete_port(k_id
)
2898 except Exception as e
:
2899 self
.logger
.error("Error deleting port: {}: {}".format(type(e
).__name
__, e
))
2901 def _delete_volumes_by_id_wth_cinder(
2902 self
, k
: str, k_id
: str, volumes_to_hold
: list, created_items
: dict
2904 """Cinder delete volume by id.
2906 k (str): Full item name in created_items
2907 k_id (str): ID of floating ip in VIM
2908 volumes_to_hold (list): Volumes not to delete
2909 created_items (dict): All created items belongs to VM
2912 if k_id
in volumes_to_hold
:
2915 if self
.cinder
.volumes
.get(k_id
).status
!= "available":
2919 self
.cinder
.volumes
.delete(k_id
)
2920 created_items
[k
] = None
2922 except Exception as e
:
2924 "Error deleting volume: {}: {}".format(type(e
).__name
__, e
)
2927 def _delete_floating_ip_by_id(self
, k
: str, k_id
: str, created_items
: dict) -> None:
2928 """Neutron delete floating ip by id.
2930 k (str): Full item name in created_items
2931 k_id (str): ID of floating ip in VIM
2932 created_items (dict): All created items belongs to VM
2935 self
.neutron
.delete_floatingip(k_id
)
2936 created_items
[k
] = None
2938 except Exception as e
:
2940 "Error deleting floating ip: {}: {}".format(type(e
).__name
__, e
)
2944 def _get_item_name_id(k
: str) -> Tuple
[str, str]:
2945 k_item
, _
, k_id
= k
.partition(":")
2948 def _delete_vm_ports_attached_to_network(self
, created_items
: dict) -> None:
2949 """Delete VM ports attached to the networks before deleting virtual machine.
2951 created_items (dict): All created items belongs to VM
2954 for k
, v
in created_items
.items():
2955 if not v
: # skip already deleted
2959 k_item
, k_id
= self
._get
_item
_name
_id
(k
)
2960 if k_item
== "port":
2961 self
._delete
_ports
_by
_id
_wth
_neutron
(k_id
)
2963 except Exception as e
:
2965 "Error deleting port: {}: {}".format(type(e
).__name
__, e
)
2968 def _delete_created_items(
2969 self
, created_items
: dict, volumes_to_hold
: list, keep_waiting
: bool
2971 """Delete Volumes and floating ip if they exist in created_items."""
2972 for k
, v
in created_items
.items():
2973 if not v
: # skip already deleted
2977 k_item
, k_id
= self
._get
_item
_name
_id
(k
)
2979 if k_item
== "volume":
2980 unavailable_vol
= self
._delete
_volumes
_by
_id
_wth
_cinder
(
2981 k
, k_id
, volumes_to_hold
, created_items
2987 elif k_item
== "floating_ip":
2988 self
._delete
_floating
_ip
_by
_id
(k
, k_id
, created_items
)
2990 except Exception as e
:
2991 self
.logger
.error("Error deleting {}: {}".format(k
, e
))
2996 def _extract_items_wth_keep_flag_from_created_items(created_items
: dict) -> dict:
2997 """Remove the volumes which has key flag from created_items
3000 created_items (dict): All created items belongs to VM
3003 created_items (dict): Persistent volumes eliminated created_items
3007 for (key
, value
) in created_items
.items()
3008 if len(key
.split(":")) == 2
3011 def delete_vminstance(
3012 self
, vm_id
: str, created_items
: dict = None, volumes_to_hold
: list = None
3014 """Removes a VM instance from VIM. Returns the old identifier.
3016 vm_id (str): Identifier of VM instance
3017 created_items (dict): All created items belongs to VM
3018 volumes_to_hold (list): Volumes_to_hold
3020 if created_items
is None:
3022 if volumes_to_hold
is None:
3023 volumes_to_hold
= []
3026 created_items
= self
._extract
_items
_wth
_keep
_flag
_from
_created
_items
(
3030 self
._reload
_connection
()
3032 # Delete VM ports attached to the networks before the virtual machine
3034 self
._delete
_vm
_ports
_attached
_to
_network
(created_items
)
3037 self
.nova
.servers
.delete(vm_id
)
3039 # Although having detached, volumes should have in active status before deleting.
3040 # We ensure in this loop
3044 while keep_waiting
and elapsed_time
< volume_timeout
:
3045 keep_waiting
= False
3047 # Delete volumes and floating IP.
3048 keep_waiting
= self
._delete
_created
_items
(
3049 created_items
, volumes_to_hold
, keep_waiting
3057 nvExceptions
.NotFound
,
3058 ksExceptions
.ClientException
,
3059 nvExceptions
.ClientException
,
3062 self
._format
_exception
(e
)
3064 def refresh_vms_status(self
, vm_list
):
3065 """Get the status of the virtual machines and their interfaces/ports
3066 Params: the list of VM identifiers
3067 Returns a dictionary with:
3068 vm_id: #VIM id of this Virtual Machine
3069 status: #Mandatory. Text with one of:
3070 # DELETED (not found at vim)
3071 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
3072 # OTHER (Vim reported other status not understood)
3073 # ERROR (VIM indicates an ERROR status)
3074 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
3075 # CREATING (on building process), ERROR
3076 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
3078 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
3079 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
3081 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
3082 mac_address: #Text format XX:XX:XX:XX:XX:XX
3083 vim_net_id: #network id where this interface is connected
3084 vim_interface_id: #interface/port VIM id
3085 ip_address: #null, or text with IPv4, IPv6 address
3086 compute_node: #identification of compute node where PF,VF interface is allocated
3087 pci: #PCI address of the NIC that hosts the PF,VF
3088 vlan: #physical VLAN used for VF
3092 "refresh_vms status: Getting tenant VM instance information from VIM"
3095 for vm_id
in vm_list
:
3099 vm_vim
= self
.get_vminstance(vm_id
)
3101 if vm_vim
["status"] in vmStatus2manoFormat
:
3102 vm
["status"] = vmStatus2manoFormat
[vm_vim
["status"]]
3104 vm
["status"] = "OTHER"
3105 vm
["error_msg"] = "VIM status reported " + vm_vim
["status"]
3107 vm_vim
.pop("OS-EXT-SRV-ATTR:user_data", None)
3108 vm_vim
.pop("user_data", None)
3109 vm
["vim_info"] = self
.serialize(vm_vim
)
3111 vm
["interfaces"] = []
3112 if vm_vim
.get("fault"):
3113 vm
["error_msg"] = str(vm_vim
["fault"])
3117 self
._reload
_connection
()
3118 port_dict
= self
.neutron
.list_ports(device_id
=vm_id
)
3120 for port
in port_dict
["ports"]:
3122 interface
["vim_info"] = self
.serialize(port
)
3123 interface
["mac_address"] = port
.get("mac_address")
3124 interface
["vim_net_id"] = port
["network_id"]
3125 interface
["vim_interface_id"] = port
["id"]
3126 # check if OS-EXT-SRV-ATTR:host is there,
3127 # in case of non-admin credentials, it will be missing
3129 if vm_vim
.get("OS-EXT-SRV-ATTR:host"):
3130 interface
["compute_node"] = vm_vim
["OS-EXT-SRV-ATTR:host"]
3132 interface
["pci"] = None
3134 # check if binding:profile is there,
3135 # in case of non-admin credentials, it will be missing
3136 if port
.get("binding:profile"):
3137 if port
["binding:profile"].get("pci_slot"):
3138 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting
3140 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
3141 # CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2) assuming there are 2 ports per nic
3142 pci
= port
["binding:profile"]["pci_slot"]
3143 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
3144 interface
["pci"] = pci
3146 interface
["vlan"] = None
3148 if port
.get("binding:vif_details"):
3149 interface
["vlan"] = port
["binding:vif_details"].get("vlan")
3151 # Get vlan from network in case not present in port for those old openstacks and cases where
3152 # it is needed vlan at PT
3153 if not interface
["vlan"]:
3154 # if network is of type vlan and port is of type direct (sr-iov) then set vlan id
3155 network
= self
.neutron
.show_network(port
["network_id"])
3158 network
["network"].get("provider:network_type")
3161 # and port.get("binding:vnic_type") in ("direct", "direct-physical"):
3162 interface
["vlan"] = network
["network"].get(
3163 "provider:segmentation_id"
3167 # look for floating ip address
3169 floating_ip_dict
= self
.neutron
.list_floatingips(
3173 if floating_ip_dict
.get("floatingips"):
3175 floating_ip_dict
["floatingips"][0].get(
3176 "floating_ip_address"
3182 for subnet
in port
["fixed_ips"]:
3183 ips
.append(subnet
["ip_address"])
3185 interface
["ip_address"] = ";".join(ips
)
3186 vm
["interfaces"].append(interface
)
3187 except Exception as e
:
3189 "Error getting vm interface information {}: {}".format(
3194 except vimconn
.VimConnNotFoundException
as e
:
3195 self
.logger
.error("Exception getting vm status: %s", str(e
))
3196 vm
["status"] = "DELETED"
3197 vm
["error_msg"] = str(e
)
3198 except vimconn
.VimConnException
as e
:
3199 self
.logger
.error("Exception getting vm status: %s", str(e
))
3200 vm
["status"] = "VIM_ERROR"
3201 vm
["error_msg"] = str(e
)
3207 def action_vminstance(self
, vm_id
, action_dict
, created_items
={}):
3208 """Send and action over a VM instance from VIM
3209 Returns None or the console dict if the action was successfully sent to the VIM
3211 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
3214 self
._reload
_connection
()
3215 server
= self
.nova
.servers
.find(id=vm_id
)
3217 if "start" in action_dict
:
3218 if action_dict
["start"] == "rebuild":
3221 if server
.status
== "PAUSED":
3223 elif server
.status
== "SUSPENDED":
3225 elif server
.status
== "SHUTOFF":
3229 "ERROR : Instance is not in SHUTOFF/PAUSE/SUSPEND state"
3231 raise vimconn
.VimConnException(
3232 "Cannot 'start' instance while it is in active state",
3233 http_code
=vimconn
.HTTP_Bad_Request
,
3236 elif "pause" in action_dict
:
3238 elif "resume" in action_dict
:
3240 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
3241 self
.logger
.debug("server status %s", server
.status
)
3242 if server
.status
== "ACTIVE":
3245 self
.logger
.debug("ERROR: VM is not in Active state")
3246 raise vimconn
.VimConnException(
3247 "VM is not in active state, stop operation is not allowed",
3248 http_code
=vimconn
.HTTP_Bad_Request
,
3250 elif "forceOff" in action_dict
:
3251 server
.stop() # TODO
3252 elif "terminate" in action_dict
:
3254 elif "createImage" in action_dict
:
3255 server
.create_image()
3256 # "path":path_schema,
3257 # "description":description_schema,
3258 # "name":name_schema,
3259 # "metadata":metadata_schema,
3260 # "imageRef": id_schema,
3261 # "disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
3262 elif "rebuild" in action_dict
:
3263 server
.rebuild(server
.image
["id"])
3264 elif "reboot" in action_dict
:
3265 server
.reboot() # reboot_type="SOFT"
3266 elif "console" in action_dict
:
3267 console_type
= action_dict
["console"]
3269 if console_type
is None or console_type
== "novnc":
3270 console_dict
= server
.get_vnc_console("novnc")
3271 elif console_type
== "xvpvnc":
3272 console_dict
= server
.get_vnc_console(console_type
)
3273 elif console_type
== "rdp-html5":
3274 console_dict
= server
.get_rdp_console(console_type
)
3275 elif console_type
== "spice-html5":
3276 console_dict
= server
.get_spice_console(console_type
)
3278 raise vimconn
.VimConnException(
3279 "console type '{}' not allowed".format(console_type
),
3280 http_code
=vimconn
.HTTP_Bad_Request
,
3284 console_url
= console_dict
["console"]["url"]
3286 protocol_index
= console_url
.find("//")
3288 console_url
[protocol_index
+ 2 :].find("/") + protocol_index
+ 2
3291 console_url
[protocol_index
+ 2 : suffix_index
].find(":")
3296 if protocol_index
< 0 or port_index
< 0 or suffix_index
< 0:
3297 raise vimconn
.VimConnException(
3298 "Unexpected response from VIM " + str(console_dict
)
3302 "protocol": console_url
[0:protocol_index
],
3303 "server": console_url
[protocol_index
+ 2 : port_index
],
3304 "port": int(console_url
[port_index
+ 1 : suffix_index
]),
3305 "suffix": console_url
[suffix_index
+ 1 :],
3308 return console_dict2
3310 raise vimconn
.VimConnException(
3311 "Unexpected response from VIM " + str(console_dict
)
3316 ksExceptions
.ClientException
,
3317 nvExceptions
.ClientException
,
3318 nvExceptions
.NotFound
,
3321 self
._format
_exception
(e
)
3322 # TODO insert exception vimconn.HTTP_Unauthorized
3324 # ###### VIO Specific Changes #########
3325 def _generate_vlanID(self
):
3327 Method to get unused vlanID
3335 networks
= self
.get_network_list()
3337 for net
in networks
:
3338 if net
.get("provider:segmentation_id"):
3339 usedVlanIDs
.append(net
.get("provider:segmentation_id"))
3341 used_vlanIDs
= set(usedVlanIDs
)
3343 # find unused VLAN ID
3344 for vlanID_range
in self
.config
.get("dataplane_net_vlan_range"):
3346 start_vlanid
, end_vlanid
= map(
3347 int, vlanID_range
.replace(" ", "").split("-")
3350 for vlanID
in range(start_vlanid
, end_vlanid
+ 1):
3351 if vlanID
not in used_vlanIDs
:
3353 except Exception as exp
:
3354 raise vimconn
.VimConnException(
3355 "Exception {} occurred while generating VLAN ID.".format(exp
)
3358 raise vimconn
.VimConnConflictException(
3359 "Unable to create the SRIOV VLAN network. All given Vlan IDs {} are in use.".format(
3360 self
.config
.get("dataplane_net_vlan_range")
3364 def _generate_multisegment_vlanID(self
):
3366 Method to get unused vlanID
3374 networks
= self
.get_network_list()
3375 for net
in networks
:
3376 if net
.get("provider:network_type") == "vlan" and net
.get(
3377 "provider:segmentation_id"
3379 usedVlanIDs
.append(net
.get("provider:segmentation_id"))
3380 elif net
.get("segments"):
3381 for segment
in net
.get("segments"):
3382 if segment
.get("provider:network_type") == "vlan" and segment
.get(
3383 "provider:segmentation_id"
3385 usedVlanIDs
.append(segment
.get("provider:segmentation_id"))
3387 used_vlanIDs
= set(usedVlanIDs
)
3389 # find unused VLAN ID
3390 for vlanID_range
in self
.config
.get("multisegment_vlan_range"):
3392 start_vlanid
, end_vlanid
= map(
3393 int, vlanID_range
.replace(" ", "").split("-")
3396 for vlanID
in range(start_vlanid
, end_vlanid
+ 1):
3397 if vlanID
not in used_vlanIDs
:
3399 except Exception as exp
:
3400 raise vimconn
.VimConnException(
3401 "Exception {} occurred while generating VLAN ID.".format(exp
)
3404 raise vimconn
.VimConnConflictException(
3405 "Unable to create the VLAN segment. All VLAN IDs {} are in use.".format(
3406 self
.config
.get("multisegment_vlan_range")
3410 def _validate_vlan_ranges(self
, input_vlan_range
, text_vlan_range
):
3412 Method to validate user given vlanID ranges
3416 for vlanID_range
in input_vlan_range
:
3417 vlan_range
= vlanID_range
.replace(" ", "")
3419 vlanID_pattern
= r
"(\d)*-(\d)*$"
3420 match_obj
= re
.match(vlanID_pattern
, vlan_range
)
3422 raise vimconn
.VimConnConflictException(
3423 "Invalid VLAN range for {}: {}.You must provide "
3424 "'{}' in format [start_ID - end_ID].".format(
3425 text_vlan_range
, vlanID_range
, text_vlan_range
3429 start_vlanid
, end_vlanid
= map(int, vlan_range
.split("-"))
3430 if start_vlanid
<= 0:
3431 raise vimconn
.VimConnConflictException(
3432 "Invalid VLAN range for {}: {}. Start ID can not be zero. For VLAN "
3433 "networks valid IDs are 1 to 4094 ".format(
3434 text_vlan_range
, vlanID_range
3438 if end_vlanid
> 4094:
3439 raise vimconn
.VimConnConflictException(
3440 "Invalid VLAN range for {}: {}. End VLAN ID can not be "
3441 "greater than 4094. For VLAN networks valid IDs are 1 to 4094 ".format(
3442 text_vlan_range
, vlanID_range
3446 if start_vlanid
> end_vlanid
:
3447 raise vimconn
.VimConnConflictException(
3448 "Invalid VLAN range for {}: {}. You must provide '{}'"
3449 " in format start_ID - end_ID and start_ID < end_ID ".format(
3450 text_vlan_range
, vlanID_range
, text_vlan_range
3454 def get_hosts_info(self
):
3455 """Get the information of deployed hosts
3456 Returns the hosts content"""
3458 print("osconnector: Getting Host info from VIM")
3462 self
._reload
_connection
()
3463 hypervisors
= self
.nova
.hypervisors
.list()
3465 for hype
in hypervisors
:
3466 h_list
.append(hype
.to_dict())
3468 return 1, {"hosts": h_list
}
3469 except nvExceptions
.NotFound
as e
:
3470 error_value
= -vimconn
.HTTP_Not_Found
3471 error_text
= str(e
) if len(e
.args
) == 0 else str(e
.args
[0])
3472 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
3473 error_value
= -vimconn
.HTTP_Bad_Request
3477 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
3480 # TODO insert exception vimconn.HTTP_Unauthorized
3481 # if reaching here is because an exception
3482 self
.logger
.debug("get_hosts_info " + error_text
)
3484 return error_value
, error_text
3486 def get_hosts(self
, vim_tenant
):
3487 """Get the hosts and deployed instances
3488 Returns the hosts content"""
3489 r
, hype_dict
= self
.get_hosts_info()
3494 hypervisors
= hype_dict
["hosts"]
3497 servers
= self
.nova
.servers
.list()
3498 for hype
in hypervisors
:
3499 for server
in servers
:
3501 server
.to_dict()["OS-EXT-SRV-ATTR:hypervisor_hostname"]
3502 == hype
["hypervisor_hostname"]
3505 hype
["vm"].append(server
.id)
3507 hype
["vm"] = [server
.id]
3510 except nvExceptions
.NotFound
as e
:
3511 error_value
= -vimconn
.HTTP_Not_Found
3512 error_text
= str(e
) if len(e
.args
) == 0 else str(e
.args
[0])
3513 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
3514 error_value
= -vimconn
.HTTP_Bad_Request
3518 + (str(e
) if len(e
.args
) == 0 else str(e
.args
[0]))
3521 # TODO insert exception vimconn.HTTP_Unauthorized
3522 # if reaching here is because an exception
3523 self
.logger
.debug("get_hosts " + error_text
)
3525 return error_value
, error_text
3527 def new_affinity_group(self
, affinity_group_data
):
3528 """Adds a server group to VIM
3529 affinity_group_data contains a dictionary with information, keys:
3530 name: name in VIM for the server group
3531 type: affinity or anti-affinity
3532 scope: Only nfvi-node allowed
3533 Returns the server group identifier"""
3534 self
.logger
.debug("Adding Server Group '%s'", str(affinity_group_data
))
3537 name
= affinity_group_data
["name"]
3538 policy
= affinity_group_data
["type"]
3540 self
._reload
_connection
()
3541 new_server_group
= self
.nova
.server_groups
.create(name
, policy
)
3543 return new_server_group
.id
3545 ksExceptions
.ClientException
,
3546 nvExceptions
.ClientException
,
3550 self
._format
_exception
(e
)
3552 def get_affinity_group(self
, affinity_group_id
):
3553 """Obtain server group details from the VIM. Returns the server group detais as a dict"""
3554 self
.logger
.debug("Getting flavor '%s'", affinity_group_id
)
3556 self
._reload
_connection
()
3557 server_group
= self
.nova
.server_groups
.find(id=affinity_group_id
)
3559 return server_group
.to_dict()
3561 nvExceptions
.NotFound
,
3562 nvExceptions
.ClientException
,
3563 ksExceptions
.ClientException
,
3566 self
._format
_exception
(e
)
3568 def delete_affinity_group(self
, affinity_group_id
):
3569 """Deletes a server group from the VIM. Returns the old affinity_group_id"""
3570 self
.logger
.debug("Getting server group '%s'", affinity_group_id
)
3572 self
._reload
_connection
()
3573 self
.nova
.server_groups
.delete(affinity_group_id
)
3575 return affinity_group_id
3577 nvExceptions
.NotFound
,
3578 ksExceptions
.ClientException
,
3579 nvExceptions
.ClientException
,
3582 self
._format
_exception
(e
)
3584 def get_vdu_state(self
, vm_id
):
3586 Getting the state of a vdu
3588 vm_id: ID of an instance
3590 self
.logger
.debug("Getting the status of VM")
3591 self
.logger
.debug("VIM VM ID %s", vm_id
)
3592 self
._reload
_connection
()
3593 server
= self
.nova
.servers
.find(id=vm_id
)
3594 server_dict
= server
.to_dict()
3596 server_dict
["status"],
3597 server_dict
["flavor"]["id"],
3598 server_dict
["OS-EXT-SRV-ATTR:host"],
3599 server_dict
["OS-EXT-AZ:availability_zone"],
3601 self
.logger
.debug("vdu_data %s", vdu_data
)
3604 def check_compute_availability(self
, host
, server_flavor_details
):
3605 self
._reload
_connection
()
3606 hypervisor_search
= self
.nova
.hypervisors
.search(
3607 hypervisor_match
=host
, servers
=True
3609 for hypervisor
in hypervisor_search
:
3610 hypervisor_id
= hypervisor
.to_dict()["id"]
3611 hypervisor_details
= self
.nova
.hypervisors
.get(hypervisor
=hypervisor_id
)
3612 hypervisor_dict
= hypervisor_details
.to_dict()
3613 hypervisor_temp
= json
.dumps(hypervisor_dict
)
3614 hypervisor_json
= json
.loads(hypervisor_temp
)
3615 resources_available
= [
3616 hypervisor_json
["free_ram_mb"],
3617 hypervisor_json
["disk_available_least"],
3618 hypervisor_json
["vcpus"] - hypervisor_json
["vcpus_used"],
3620 compute_available
= all(
3621 x
> y
for x
, y
in zip(resources_available
, server_flavor_details
)
3623 if compute_available
:
3626 def check_availability_zone(
3627 self
, old_az
, server_flavor_details
, old_host
, host
=None
3629 self
._reload
_connection
()
3630 az_check
= {"zone_check": False, "compute_availability": None}
3631 aggregates_list
= self
.nova
.aggregates
.list()
3632 for aggregate
in aggregates_list
:
3633 aggregate_details
= aggregate
.to_dict()
3634 aggregate_temp
= json
.dumps(aggregate_details
)
3635 aggregate_json
= json
.loads(aggregate_temp
)
3636 if aggregate_json
["availability_zone"] == old_az
:
3637 hosts_list
= aggregate_json
["hosts"]
3638 if host
is not None:
3639 if host
in hosts_list
:
3640 az_check
["zone_check"] = True
3641 available_compute_id
= self
.check_compute_availability(
3642 host
, server_flavor_details
3644 if available_compute_id
is not None:
3645 az_check
["compute_availability"] = available_compute_id
3647 for check_host
in hosts_list
:
3648 if check_host
!= old_host
:
3649 available_compute_id
= self
.check_compute_availability(
3650 check_host
, server_flavor_details
3652 if available_compute_id
is not None:
3653 az_check
["zone_check"] = True
3654 az_check
["compute_availability"] = available_compute_id
3657 az_check
["zone_check"] = True
3660 def migrate_instance(self
, vm_id
, compute_host
=None):
3664 vm_id: ID of an instance
3665 compute_host: Host to migrate the vdu to
3667 self
._reload
_connection
()
3669 instance_state
= self
.get_vdu_state(vm_id
)
3670 server_flavor_id
= instance_state
[1]
3671 server_hypervisor_name
= instance_state
[2]
3672 server_availability_zone
= instance_state
[3]
3674 server_flavor
= self
.nova
.flavors
.find(id=server_flavor_id
).to_dict()
3675 server_flavor_details
= [
3676 server_flavor
["ram"],
3677 server_flavor
["disk"],
3678 server_flavor
["vcpus"],
3680 if compute_host
== server_hypervisor_name
:
3681 raise vimconn
.VimConnException(
3682 "Unable to migrate instance '{}' to the same host '{}'".format(
3685 http_code
=vimconn
.HTTP_Bad_Request
,
3687 az_status
= self
.check_availability_zone(
3688 server_availability_zone
,
3689 server_flavor_details
,
3690 server_hypervisor_name
,
3693 availability_zone_check
= az_status
["zone_check"]
3694 available_compute_id
= az_status
.get("compute_availability")
3696 if availability_zone_check
is False:
3697 raise vimconn
.VimConnException(
3698 "Unable to migrate instance '{}' to a different availability zone".format(
3701 http_code
=vimconn
.HTTP_Bad_Request
,
3703 if available_compute_id
is not None:
3704 self
.nova
.servers
.live_migrate(
3706 host
=available_compute_id
,
3707 block_migration
=True,
3708 disk_over_commit
=False,
3711 changed_compute_host
= ""
3712 if state
== "MIGRATING":
3713 vm_state
= self
.__wait
_for
_vm
(vm_id
, "ACTIVE")
3714 changed_compute_host
= self
.get_vdu_state(vm_id
)[2]
3715 if vm_state
and changed_compute_host
== available_compute_id
:
3717 "Instance '{}' migrated to the new compute host '{}'".format(
3718 vm_id
, changed_compute_host
3721 return state
, available_compute_id
3723 raise vimconn
.VimConnException(
3724 "Migration Failed. Instance '{}' not moved to the new host {}".format(
3725 vm_id
, available_compute_id
3727 http_code
=vimconn
.HTTP_Bad_Request
,
3730 raise vimconn
.VimConnException(
3731 "Compute '{}' not available or does not have enough resources to migrate the instance".format(
3732 available_compute_id
3734 http_code
=vimconn
.HTTP_Bad_Request
,
3737 nvExceptions
.BadRequest
,
3738 nvExceptions
.ClientException
,
3739 nvExceptions
.NotFound
,
3741 self
._format
_exception
(e
)
3743 def resize_instance(self
, vm_id
, new_flavor_id
):
3745 For resizing the vm based on the given
3748 vm_id : ID of an instance
3749 new_flavor_id : Flavor id to be resized
3750 Return the status of a resized instance
3752 self
._reload
_connection
()
3753 self
.logger
.debug("resize the flavor of an instance")
3754 instance_status
, old_flavor_id
, compute_host
, az
= self
.get_vdu_state(vm_id
)
3755 old_flavor_disk
= self
.nova
.flavors
.find(id=old_flavor_id
).to_dict()["disk"]
3756 new_flavor_disk
= self
.nova
.flavors
.find(id=new_flavor_id
).to_dict()["disk"]
3758 if instance_status
== "ACTIVE" or instance_status
== "SHUTOFF":
3759 if old_flavor_disk
> new_flavor_disk
:
3760 raise nvExceptions
.BadRequest(
3762 message
="Server disk resize failed. Resize to lower disk flavor is not allowed",
3765 self
.nova
.servers
.resize(server
=vm_id
, flavor
=new_flavor_id
)
3766 vm_state
= self
.__wait
_for
_vm
(vm_id
, "VERIFY_RESIZE")
3768 instance_resized_status
= self
.confirm_resize(vm_id
)
3769 return instance_resized_status
3771 raise nvExceptions
.BadRequest(
3773 message
="Cannot 'resize' vm_state is in ERROR",
3777 self
.logger
.debug("ERROR : Instance is not in ACTIVE or SHUTOFF state")
3778 raise nvExceptions
.BadRequest(
3780 message
="Cannot 'resize' instance while it is in vm_state resized",
3783 nvExceptions
.BadRequest
,
3784 nvExceptions
.ClientException
,
3785 nvExceptions
.NotFound
,
3787 self
._format
_exception
(e
)
3789 def confirm_resize(self
, vm_id
):
3791 Confirm the resize of an instance
3793 vm_id: ID of an instance
3795 self
._reload
_connection
()
3796 self
.nova
.servers
.confirm_resize(server
=vm_id
)
3797 if self
.get_vdu_state(vm_id
)[0] == "VERIFY_RESIZE":
3798 self
.__wait
_for
_vm
(vm_id
, "ACTIVE")
3799 instance_status
= self
.get_vdu_state(vm_id
)[0]
3800 return instance_status