Tacker: ETSI MANO NFV Orchestrator / VNF Manager. See https://wiki.openstack.org/wiki/Tacker
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

2324 lines
101 KiB

# Copyright 2017 OpenStack Foundation
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import copy
import datetime
import functools
import inspect
import json
import os
import oslo_messaging
import requests
import shutil
import sys
import time
import traceback
import yaml
from glance_store import exceptions as store_exceptions
from oslo_config import cfg
from oslo_log import log as logging
from oslo_serialization import jsonutils
from oslo_service import periodic_task
from oslo_service import service
from oslo_utils import encodeutils
from oslo_utils import excutils
from oslo_utils import timeutils
from oslo_utils import uuidutils
from sqlalchemy import exc as sqlexc
from sqlalchemy.orm import exc as orm_exc
from tacker import auth
from tacker.common import coordination
from tacker.common import csar_utils
from tacker.common import driver_manager
from tacker.common import exceptions
from tacker.common import log
from tacker.common import safe_utils
from tacker.common import topics
from tacker.common import utils
import tacker.conf
from tacker import context as t_context
from tacker.db.common_services import common_services_db
from tacker.db.db_sqlalchemy import models
from tacker.db.nfvo import nfvo_db
from tacker.db.vnfm import vnfm_db
from tacker.extensions import nfvo
from tacker.glance_store import store as glance_store
from tacker import manager
from tacker import objects
from tacker.objects import fields
from tacker.objects.fields import ErrorPoint as EP
from tacker.objects.vnf_package import VnfPackagesList
from tacker.objects import vnfd as vnfd_db
from tacker.objects import vnfd_attribute as vnfd_attribute_db
from tacker.plugins.common import constants
from tacker import service as tacker_service
from tacker import version
from tacker.vnflcm import utils as vnflcm_utils
from tacker.vnflcm import vnflcm_driver
from tacker.vnfm import nfvo_client
from tacker.vnfm import plugin
CONF = tacker.conf.CONF
# NOTE(tpatil): keystone_authtoken opts registered explicitly as conductor
# service doesn't use the keystonemiddleware.authtoken middleware as it's
# used by the tacker.service in the api-paste.ini
OPTS = [cfg.StrOpt('user_domain_id',
default='default',
help='User Domain Id'),
cfg.StrOpt('project_domain_id',
default='default',
help='Project Domain Id'),
cfg.StrOpt('password',
default='default',
help='User Password'),
cfg.StrOpt('username',
default='default',
help='User Name'),
cfg.StrOpt('user_domain_name',
default='default',
help='Use Domain Name'),
cfg.StrOpt('project_name',
default='default',
help='Project Name'),
cfg.StrOpt('project_domain_name',
default='default',
help='Project Domain Name'),
cfg.StrOpt('auth_url',
default='http://localhost/identity/v3',
help='Keystone endpoint')]
cfg.CONF.register_opts(OPTS, 'keystone_authtoken')
LOG = logging.getLogger(__name__)
_INACTIVE_STATUS = ('INACTIVE',)
_ACTIVE_STATUS = ('ACTIVE',)
_PENDING_STATUS = ('PENDING_CREATE',
'PENDING_TERMINATE',
'PENDING_DELETE',
'PENDING_HEAL',
'PENDING_CHANGE_EXT_CONN')
_ERROR_STATUS = ('ERROR',)
_ALL_STATUSES = _ACTIVE_STATUS + _INACTIVE_STATUS + _PENDING_STATUS + \
_ERROR_STATUS
def _delete_csar(context, vnf_package):
# Delete from glance store
glance_store.delete_csar(context, vnf_package.id,
vnf_package.location_glance_store)
csar_utils.delete_csar_data(vnf_package.id)
@utils.expects_func_args('vnf_package')
def revert_upload_vnf_package(function):
"""Decorator to revert upload_vnf_package on failure."""
@functools.wraps(function)
def decorated_function(self, context, *args, **kwargs):
try:
return function(self, context, *args, **kwargs)
except Exception as exp:
with excutils.save_and_reraise_exception():
wrapped_func = safe_utils.get_wrapped_function(function)
keyed_args = inspect.getcallargs(wrapped_func, self, context,
*args, **kwargs)
context = keyed_args['context']
vnf_package = keyed_args['vnf_package']
if not (isinstance(exp, exceptions.UploadFailedToGlanceStore)
or isinstance(exp, exceptions.VNFPackageURLInvalid)):
# Delete the csar file from the glance store.
glance_store.delete_csar(context, vnf_package.id,
vnf_package.location_glance_store)
csar_utils.delete_csar_data(vnf_package.id)
# Delete the vnf_deployment_flavour if created.
if vnf_package.vnf_deployment_flavours:
for flavour in vnf_package.vnf_deployment_flavours:
flavour.destroy(context)
# Set the vnf package onboarding status to created,
# so that user can retry uploading vnf package
# after correcting the csar zip file.
vnf_package.onboarding_state = (
fields.PackageOnboardingStateType.CREATED)
vnf_package.save()
return decorated_function
@utils.expects_func_args('vnf_lcm_opoccs')
def revert_update_lcm(function):
"""Decorator to revert update_lcm on failure."""
@functools.wraps(function)
def decorated_function(self, context, *args, **kwargs):
try:
return function(self, context, *args, **kwargs)
except Exception as exp:
LOG.error("update vnf_instance failed %s" % exp)
with excutils.save_and_reraise_exception():
wrapped_func = safe_utils.get_wrapped_function(function)
keyed_args = inspect.getcallargs(wrapped_func, self, context,
*args, **kwargs)
context = keyed_args['context']
vnf_lcm_opoccs = keyed_args['vnf_lcm_opoccs']
try:
# update vnf
vnf_now = timeutils.utcnow()
vnf_obj = objects.vnf.VNF(context=context)
vnf_obj.id = vnf_lcm_opoccs.get('vnf_instance_id')
vnf_obj.status = 'ERROR'
vnf_obj.updated_at = vnf_now
vnf_obj.save()
e_msg = str(exp)
# update lcm_op_occs
problem_obj = objects.vnf_lcm_op_occs.ProblemDetails()
problem_obj.status = '500'
problem_obj.detail = e_msg
lcm_op_obj = objects.vnf_lcm_op_occs.VnfLcmOpOcc(
context=context)
lcm_op_obj.id = vnf_lcm_opoccs.get('id')
lcm_op_obj.operation_state =\
fields.LcmOccsOperationState.FAILED_TEMP
lcm_op_obj.error = problem_obj
lcm_op_obj.state_entered_time = vnf_now
lcm_op_obj.updated_at = vnf_now
lcm_op_obj.save()
# Notification
notification = {}
notification['notificationType'] = \
'VnfLcmOperationOccurrenceNotification'
notification['notificationStatus'] = 'RESULT'
notification['operationState'] = \
fields.LcmOccsOperationState.FAILED_TEMP
notification['vnfInstanceId'] = vnf_lcm_opoccs.get(
'vnf_instance_id')
notification['operation'] = 'MODIFY_INFO'
notification['isAutomaticInvocation'] = 'False'
notification['vnfLcmOpOccId'] = vnf_lcm_opoccs.get('id')
notification['error'] = jsonutils.dumps(
problem_obj.to_dict())
instance_url = self._get_vnf_instance_href(
vnf_lcm_opoccs.get('vnf_instance_id'))
lcm_url = self._get_vnf_lcm_op_occs_href(
vnf_lcm_opoccs.get('id'))
notification['_links'] = {
'vnfInstance': {
'href': instance_url},
'vnfLcmOpOcc': {
'href': lcm_url}}
self.send_notification(context, notification)
except Exception as msg:
LOG.error("revert_update_lcm failed %s" % str(msg))
return decorated_function
@utils.expects_func_args('vnf_instance', 'vnf_lcm_op_occ_id')
def grant_error_common(function):
"""Decorator to revert upload_vnf_package on failure."""
@functools.wraps(function)
def decorated_function(self, context, *args, **kwargs):
try:
return function(self, context, *args, **kwargs)
except Exception:
with excutils.save_and_reraise_exception():
wrapped_func = safe_utils.get_wrapped_function(function)
keyed_args = inspect.getcallargs(wrapped_func, self, context,
*args, **kwargs)
context = keyed_args['context']
vnf_instance = keyed_args['vnf_instance']
vnf_lcm_op_occ_id = keyed_args['vnf_lcm_op_occ_id']
try:
vnf_lcm_op_occs = objects.VnfLcmOpOcc.get_by_id(
context, vnf_lcm_op_occ_id)
timestamp = datetime.datetime.utcnow()
vnf_lcm_op_occs.operation_state = 'ROLLED_BACK'
vnf_lcm_op_occs.state_entered_time = timestamp
vnf_lcm_op_occs.save()
except Exception as e:
LOG.warning("Failed to update vnf_lcm_op_occ for vnf "
"instance %(id)s. Error: %(error)s",
{"id": vnf_instance.id, "error": e})
try:
notification = {}
notification['notificationType'] = \
'VnfLcmOperationOccurrenceNotification'
notification['vnfInstanceId'] = vnf_instance.id
notification['notificationStatus'] = 'RESULT'
notification['operation'] = vnf_lcm_op_occs.operation
notification['operationState'] = 'ROLLED_BACK'
notification['isAutomaticInvocation'] = \
vnf_lcm_op_occs.is_automatic_invocation
notification['vnfLcmOpOccId'] = vnf_lcm_op_occ_id
insta_url = CONF.vnf_lcm.endpoint_url + \
"/vnflcm/v1/vnf_instances/" + \
vnf_instance.id
vnflcm_url = CONF.vnf_lcm.endpoint_url + \
"/vnflcm/v1/vnf_lcm_op_occs/" + \
vnf_lcm_op_occ_id
notification['_links'] = {}
notification['_links']['vnfInstance'] = {}
notification['_links']['vnfInstance']['href'] = insta_url
notification['_links']['vnfLcmOpOcc'] = {}
notification['_links']['vnfLcmOpOcc']['href'] = vnflcm_url
self.send_notification(context, notification)
except Exception as e:
LOG.warning("Failed notification for vnf "
"instance %(id)s. Error: %(error)s",
{"id": vnf_instance.id, "error": e})
return decorated_function
class Conductor(manager.Manager):
def __init__(self, host, conf=None):
if conf:
self.conf = conf
else:
self.conf = CONF
super(Conductor, self).__init__(host=self.conf.host)
self.vnfm_plugin = plugin.VNFMPlugin()
self.vnflcm_driver = vnflcm_driver.VnfLcmDriver()
self.vnf_manager = driver_manager.DriverManager(
'tacker.tacker.vnfm.drivers',
cfg.CONF.tacker.infra_driver)
def start(self):
coordination.COORDINATOR.start()
def stop(self):
coordination.COORDINATOR.stop()
def init_host(self):
glance_store.initialize_glance_store()
self._basic_config_check()
def _get_vnf_instance_href(self, vnf_instance_id):
return '{endpoint}/vnflcm/v1/vnf_instances/{id}'.format(
endpoint=CONF.vnf_lcm.endpoint_url.rstrip("/"),
id=vnf_instance_id)
def _get_vnf_lcm_op_occs_href(self, vnf_lcm_op_occs_id):
return '{endpoint}/vnflcm/v1/vnf_lcm_op_occs/{id}'.format(
endpoint=CONF.vnf_lcm.endpoint_url.rstrip("/"),
id=vnf_lcm_op_occs_id)
def _basic_config_check(self):
if not os.path.isdir(CONF.vnf_package.vnf_package_csar_path):
LOG.error("Config option 'vnf_package_csar_path' is not "
"configured correctly. VNF package CSAR path directory"
" %s doesn't exist",
CONF.vnf_package.vnf_package_csar_path)
sys.exit(1)
def update_vim(self, context, vim_id, status):
t_admin_context = t_context.get_admin_context()
update_time = timeutils.utcnow()
with t_admin_context.session.begin(subtransactions=True):
try:
query = t_admin_context.session.query(nfvo_db.Vim)
query.filter(
nfvo_db.Vim.id == vim_id).update(
{'status': status,
'updated_at': update_time})
except orm_exc.NoResultFound:
raise nfvo.VimNotFoundException(vim_id=vim_id)
event_db = common_services_db.Event(
resource_id=vim_id,
resource_type=constants.RES_TYPE_VIM,
resource_state=status,
event_details="",
event_type=constants.RES_EVT_MONITOR,
timestamp=update_time)
t_admin_context.session.add(event_db)
return status
def _create_software_images(self, context, sw_image, flavour_uuid):
vnf_sw_image = objects.VnfSoftwareImage(context=context)
vnf_sw_image.flavour_uuid = flavour_uuid
vnf_sw_image.name = sw_image.get('name')
# TODO(nirajsingh) Provider is mandatory as per SOL005 but it's not
# a required parameter in SwImageData as per SOL001. SOL001 will be
# amended to make `provider` a required parameter as per
# 'https://docbox.etsi.org/ISG/NFV/SOL/05-CONTRIBUTIONS/2019/
# NFVSOL000338_SOL001ed271_SwImage_Provider.docx'.
vnf_sw_image.provider = sw_image.get('provider', "")
vnf_sw_image.version = sw_image.get('version')
if sw_image.get('checksum'):
checksum = sw_image.get('checksum')
if checksum.get('algorithm'):
vnf_sw_image.algorithm = checksum.get('algorithm')
if checksum.get('hash'):
vnf_sw_image.hash = checksum.get('hash')
vnf_sw_image.container_format = sw_image.get('container_format')
vnf_sw_image.disk_format = sw_image.get('disk_format')
if sw_image.get('min_ram'):
vnf_sw_image.min_ram = sw_image.get('min_ram')
else:
vnf_sw_image.min_ram = 0
vnf_sw_image.min_disk = sw_image.get('min_disk')
vnf_sw_image.size = sw_image.get('size')
vnf_sw_image.image_path = ''
vnf_sw_image.software_image_id = sw_image['software_image_id']
vnf_sw_image.metadata = sw_image.get('metadata', dict())
vnf_sw_image.create()
def _create_flavour(self, context, package_uuid, flavour):
deploy_flavour = objects.VnfDeploymentFlavour(context=context)
deploy_flavour.package_uuid = package_uuid
deploy_flavour.flavour_id = flavour['flavour_id']
deploy_flavour.flavour_description = flavour['flavour_description']
deploy_flavour.instantiation_levels = \
flavour.get('instantiation_levels')
deploy_flavour.create()
sw_images = flavour.get('sw_images')
if sw_images:
for sw_image in sw_images:
self._create_software_images(
context, sw_image, deploy_flavour.id)
def _create_vnf_artifacts(self, context, package_uuid, artifact):
vnf_artifact = objects.VnfPackageArtifactInfo(context=context)
vnf_artifact.package_uuid = package_uuid
vnf_artifact.artifact_path = artifact['Source']
vnf_artifact.algorithm = artifact['Algorithm']
vnf_artifact.hash = artifact['Hash']
vnf_artifact._metadata = {}
vnf_artifact.create()
def _onboard_vnf_package(
self,
context,
vnf_package,
vnf_data,
flavours,
vnf_artifacts):
if vnf_artifacts:
for artifact in vnf_artifacts:
self._create_vnf_artifacts(context, vnf_package.id, artifact)
package_vnfd = objects.VnfPackageVnfd(context=context)
package_vnfd.package_uuid = vnf_package.id
package_vnfd.vnfd_id = vnf_data.get('descriptor_id')
package_vnfd.vnf_provider = vnf_data.get('provider')
package_vnfd.vnf_product_name = vnf_data.get('product_name')
package_vnfd.vnf_software_version = vnf_data.get('software_version')
package_vnfd.vnfd_version = vnf_data.get('descriptor_version')
package_vnfd.create()
self._onboard_vnfd(context, vnf_package, vnf_data, flavours)
for flavour in flavours:
self._create_flavour(context, vnf_package.id, flavour)
def _onboard_vnfd(self, context, vnf_package, vnf_data, flavours):
vnfd = vnfd_db.Vnfd(context=context)
vnfd.id = vnf_data.get('descriptor_id')
vnfd.tenant_id = context.tenant_id
vnfd.name = vnf_data.get('product_name') + '-' + \
vnf_data.get('descriptor_version')
vnfd.discription = vnf_data.get('discription')
for flavour in flavours:
if flavour.get('mgmt_driver'):
vnfd.mgmt_driver = flavour.get('mgmt_driver')
break
vnfd.create()
for flavour in flavours:
vnfd_attribute = vnfd_attribute_db.VnfdAttribute(context=context)
vnfd_attribute.id = uuidutils.generate_uuid()
vnfd_attribute.vnfd_id = vnf_data.get('descriptor_id')
vnfd_attribute.key = 'vnfd_' + flavour['flavour_id']
vnfd_attribute.value = \
yaml.dump(flavour.get('tpl_dict'), default_flow_style=False)
vnfd_attribute.create()
@revert_upload_vnf_package
def upload_vnf_package_content(self, context, vnf_package):
vnf_package.onboarding_state = (
fields.PackageOnboardingStateType.PROCESSING)
try:
vnf_package.save()
location = vnf_package.location_glance_store
zip_path = glance_store.load_csar(vnf_package.id, location)
vnf_data, flavours, vnf_artifacts = csar_utils.load_csar_data(
context.elevated(), vnf_package.id, zip_path)
self._onboard_vnf_package(
context,
vnf_package,
vnf_data,
flavours,
vnf_artifacts)
vnf_package.onboarding_state = (
fields.PackageOnboardingStateType.ONBOARDED)
vnf_package.operational_state = (
fields.PackageOperationalStateType.ENABLED)
vnf_package.save()
except Exception as msg:
raise Exception(msg)
@revert_upload_vnf_package
def upload_vnf_package_from_uri(self, context, vnf_package,
address_information, user_name=None,
password=None):
body = {"address_information": address_information,
"user_name": user_name,
"password": password}
(location, size, checksum, multihash,
loc_meta) = glance_store.store_csar(context, vnf_package.id, body)
vnf_package.onboarding_state = (
fields.PackageOnboardingStateType.PROCESSING)
vnf_package.algorithm = CONF.vnf_package.hashing_algorithm
vnf_package.hash = multihash
vnf_package.location_glance_store = location
vnf_package.size = size
vnf_package.save()
zip_path = glance_store.load_csar(vnf_package.id, location)
vnf_data, flavours, vnf_artifacts = csar_utils.load_csar_data(
context.elevated(), vnf_package.id, zip_path)
self._onboard_vnf_package(
context,
vnf_package,
vnf_data,
flavours,
vnf_artifacts)
vnf_package.onboarding_state = (
fields.PackageOnboardingStateType.ONBOARDED)
vnf_package.operational_state = (
fields.PackageOperationalStateType.ENABLED)
vnf_package.save()
def delete_vnf_package(self, context, vnf_package):
if (vnf_package.onboarding_state ==
fields.PackageOnboardingStateType.ONBOARDED):
_delete_csar(context, vnf_package)
vnf_package.destroy(context)
def get_vnf_package_vnfd(self, context, vnf_package):
csar_path = os.path.join(CONF.vnf_package.vnf_package_csar_path,
vnf_package.id)
if not os.path.isdir(csar_path):
location = vnf_package.location_glance_store
try:
zip_path = glance_store.load_csar(vnf_package.id, location)
csar_utils.extract_csar_zip_file(zip_path, csar_path)
except (store_exceptions.GlanceStoreException) as e:
exc_msg = encodeutils.exception_to_unicode(e)
msg = (_("Exception raised from glance store can be "
"unrecoverable if it is not related to connection"
" error. Error: %s.") % exc_msg)
raise exceptions.FailedToGetVnfdData(error=msg)
try:
return self._read_vnfd_files(csar_path)
except Exception as e:
exc_msg = encodeutils.exception_to_unicode(e)
msg = (_("Exception raised while reading csar file"
" Error: %s.") % exc_msg)
raise exceptions.FailedToGetVnfdData(error=msg)
def _read_vnfd_files(self, csar_path):
"""Creating a dictionary with file path as key and file data as value.
It will contain YAML files representing the VNFD, and information
necessary to navigate the ZIP file and to identify the file that is
the entry point for parsing the VNFD such as TOSCA-meta is included.
"""
def _add_recursively_imported_files(imported_yamls, file_path_and_data,
dir_of_parent_definition_file=''):
for file in imported_yamls:
file_path = os.path.join(
csar_path, dir_of_parent_definition_file, file)
with open(file_path) as f:
file_data = yaml.safe_load(f)
dest_file_path = os.path.abspath(file_path).split(
csar_path + '/')[-1]
file_path_and_data[dest_file_path] = yaml.dump(file_data)
if file_data.get('imports'):
dir_of_parent_definition_file = '/'.join(
file_path.split('/')[:-1])
_add_recursively_imported_files(
file_data['imports'], file_path_and_data,
dir_of_parent_definition_file)
file_path_and_data = {}
if 'TOSCA-Metadata' in os.listdir(csar_path) and os.path.isdir(
os.path.join(csar_path, 'TOSCA-Metadata')):
# This is CSAR containing a TOSCA-Metadata directory, which
# includes the TOSCA.meta metadata file providing an entry
# information for processing a CSAR file.
with open(os.path.join(
csar_path, 'TOSCA-Metadata', 'TOSCA.meta')) as f:
tosca_meta_data = yaml.safe_load(f)
file_path_and_data['TOSCA-Metadata/TOSCA.meta'] = yaml.dump(
tosca_meta_data)
entry_defination_file = tosca_meta_data['Entry-Definitions']
_add_recursively_imported_files([entry_defination_file],
file_path_and_data)
else:
# This is a CSAR without a TOSCA-Metadata directory and containing
# a single yaml file with a .yml or .yaml extension at the root of
# the archive.
root_yaml_file = sorted(
os.listdir(csar_path),
key=lambda item: item.endswith(('yaml', '.yml')))[-1]
src_path = os.path.join(csar_path, root_yaml_file)
with open(src_path) as f:
file_data = yaml.safe_load(f)
file_path_and_data[root_yaml_file] = yaml.dump(file_data)
return file_path_and_data
@coordination.synchronized('{vnf_package[id]}')
def _update_package_usage_state(self, context, vnf_package):
"""Update vnf package usage state to IN_USE/NOT_IN_USE
If vnf package is not used by any of the vnf instances, it's usage
state should be set to NOT_IN_USE otherwise it should be set to
IN_USE.
"""
result = vnf_package.is_package_in_use(context)
if result:
vnf_package.usage_state = fields.PackageUsageStateType.IN_USE
else:
vnf_package.usage_state = fields.PackageUsageStateType.NOT_IN_USE
vnf_package.save()
@log.log
def _change_vnf_status(self, context, vnf_id,
current_statuses, new_status, error_reason=None):
'''Change vnf status and add error reason if error'''
LOG.debug("Change status of vnf %s from %s to %s", vnf_id,
current_statuses, new_status)
with context.session.begin(subtransactions=True):
updated_values = {
'status': new_status, 'updated_at': timeutils.utcnow()}
vnf_model = (context.session.query(
vnfm_db.VNF).filter_by(id=vnf_id).first())
if not vnf_model:
raise exceptions.VnfInstanceNotFound(
message="VNF {} not found".format(vnf_id))
if vnf_model.status not in current_statuses:
raise exceptions.VnfConflictState(
message='Cannot change status to {} \
while in {}'.format(
updated_values['status'], vnf_model.status))
vnf_model.update(updated_values)
def _update_vnf_attributes(self, context, vnf_instance, vnf_dict,
current_statuses, new_status):
with context.session.begin(subtransactions=True):
try:
modified_attributes = {}
added_attributes = {}
updated_values = {
'mgmt_ip_address': vnf_dict['mgmt_ip_address'],
'status': new_status,
'updated_at': timeutils.utcnow()}
vnf_model = (context.session.query(vnfm_db.VNF).filter_by(
id=vnf_dict['id']).first())
if not vnf_model:
raise exceptions.VnfInstanceNotFound(
message="VNF {} not found".format(vnf_dict['id']))
if vnf_model.status not in current_statuses:
raise exceptions.VnfConflictState(
message='Cannot change status to {} while \
in {}'.format(updated_values['status'],
vnf_model.status))
if hasattr(vnf_instance.instantiated_vnf_info, 'instance_id'):
instance_id = \
vnf_instance.instantiated_vnf_info.instance_id
if instance_id:
# add instance_id info
updated_values.update({'instance_id': instance_id})
vnf_model.update(updated_values)
for key, val in vnf_dict['attributes'].items():
vnf_attr_model = (context.session.query(
vnfm_db.VNFAttribute).
filter_by(vnf_id=vnf_dict['id']).
filter_by(key=key).first())
if vnf_attr_model:
modified_attributes.update(
{vnf_attr_model.key: vnf_attr_model.value})
vnf_attr_model.update({'value': val})
else:
added_attributes.update({key: val})
vnf_attr_model = vnfm_db.VNFAttribute(
id=uuidutils.generate_uuid(),
vnf_id=vnf_dict['id'],
key=key, value=val)
context.session.add(vnf_attr_model)
except Exception as exc:
with excutils.save_and_reraise_exception():
LOG.error("Error in updating tables {}".format(str(exc)))
# Roll back modified/added vnf attributes
for key, val in modified_attributes.items():
vnf_attr_model = (context.session.query(
vnfm_db.VNFAttribute).
filter_by(vnf_id=vnf_dict['id']).
filter_by(key=key).first())
if vnf_attr_model:
vnf_attr_model.update({'value': val})
for key, val in added_attributes.items():
vnf_attr_model = (context.session.query(
vnfm_db.VNFAttribute).
filter_by(vnf_id=vnf_dict['id']).
filter_by(key=key).first())
if vnf_attr_model:
vnf_attr_model.delete()
@log.log
def _build_instantiated_vnf_info(self, context, vnf_instance,
instantiate_vnf_req=None):
try:
# if instantiate_vnf_req is not present, create from vnf_instance
if not instantiate_vnf_req:
instantiate_vnf_req = objects.InstantiateVnfRequest.\
from_vnf_instance(vnf_instance)
# update instantiated vnf info based on created stack resources
if hasattr(vnf_instance.instantiated_vnf_info, 'instance_id'):
# get final vnfd_dict
vnfd_dict = vnflcm_utils._get_vnfd_dict(context,
vnf_instance.vnfd_id,
instantiate_vnf_req.flavour_id)
# get vim_connection info from request
vim_info = vnflcm_utils._get_vim(context,
instantiate_vnf_req.vim_connection_info)
vim_connection_info = objects.VimConnectionInfo.\
obj_from_primitive(vim_info, context)
if not vnf_instance.instantiated_vnf_info.instance_id:
vnflcm_utils._build_instantiated_vnf_info(
vnfd_dict, instantiate_vnf_req, vnf_instance,
vim_id=vim_connection_info.vim_id)
if vnf_instance.instantiated_vnf_info.instance_id:
self.vnf_manager.invoke(vim_connection_info.vim_type,
'post_vnf_instantiation', context=context,
vnf_instance=vnf_instance,
vim_connection_info=vim_connection_info,
instantiate_vnf_req=instantiate_vnf_req)
except Exception as ex:
try:
vnf_instance.instantiated_vnf_info.reinitialize()
vnf_instance.instantiated_vnf_info.save()
finally:
error_msg = "Failed to build instantiation information \
for vnf {} because {}".\
format(vnf_instance.id, encodeutils.
exception_to_unicode(ex))
LOG.error("_build_instantiated_vnf_info error {}".
format(error_msg))
raise exceptions.TackerException(message=error_msg)
@log.log
def _update_instantiated_vnf_info(
self, context, vnf_instance, heal_vnf_request):
try:
vim_info = vnflcm_utils._get_vim(context,
vnf_instance.vim_connection_info)
vim_connection_info = \
objects.VimConnectionInfo.obj_from_primitive(
vim_info, context)
self.vnf_manager.invoke(
vim_connection_info.vim_type, 'post_heal_vnf',
context=context, vnf_instance=vnf_instance,
vim_connection_info=vim_connection_info,
heal_vnf_request=heal_vnf_request)
except Exception as exp:
error_msg = \
"Failed to update instantiation information for vnf {}: {}".\
format(vnf_instance.id, encodeutils.exception_to_unicode(exp))
LOG.error("_update_instantiated_vnf_info error {}".
format(error_msg))
raise exceptions.TackerException(message=error_msg)
@log.log
def _update_instantiated_vnf_info_change_ext_conn(
self, context, vnf_instance, change_ext_conn_req):
try:
vim_info = vnflcm_utils._get_vim(context,
vnf_instance.vim_connection_info)
vim_connection_info = \
objects.VimConnectionInfo.obj_from_primitive(
vim_info, context)
self.vnf_manager.invoke(
vim_connection_info.vim_type, 'post_change_ext_conn_vnf',
context=context, vnf_instance=vnf_instance,
vim_connection_info=vim_connection_info)
vnflcm_utils._update_instantiated_vnf_info(
change_ext_conn_req, vnf_instance)
vnf_instance.instantiated_vnf_info.save()
except Exception as exp:
error_msg = \
"Failed to update instantiation information for vnf {}: {}".\
format(vnf_instance.id, encodeutils.exception_to_unicode(exp))
raise exceptions.TackerException(message=error_msg)
@log.log
def _add_additional_vnf_info(self, context, vnf_instance):
'''this method adds misc info to 'vnf' table'''
try:
if hasattr(vnf_instance.instantiated_vnf_info, 'instance_id'):
if vnf_instance.instantiated_vnf_info.instance_id:
# add instance_id info
instance_id = vnf_instance.instantiated_vnf_info.\
instance_id
with context.session.begin(subtransactions=True):
updated_values = {'instance_id': instance_id}
context.session.query(vnfm_db.VNF).filter_by(
id=vnf_instance.id).update(updated_values)
except Exception as ex:
# with excutils.save_and_reraise_exception():
error_msg = "Failed to add additional vnf info to vnf {}. Details -\
{}".format(
vnf_instance.id, str(ex))
LOG.error("_add_additional_vnf_info error {}".format(error_msg))
raise exceptions.TackerException(message=error_msg)
@periodic_task.periodic_task(spacing=CONF.vnf_package_delete_interval)
def _run_cleanup_vnf_packages(self, context):
"""Delete orphan extracted csar zip and files from extracted path
This periodic task will get all deleted packages for the period
(now - CONF.vnf_package_delete_interval) and delete any left out
csar zip files and vnf packages files from the extracted path.
"""
time_duration = datetime.datetime.utcnow() - datetime.timedelta(
seconds=CONF.vnf_package_delete_interval)
filters = {'field': 'deleted_at', 'model': 'VnfPackage',
'value': time_duration,
'op': '>='}
deleted_vnf_packages = VnfPackagesList.get_by_filters(
context.elevated(), read_deleted='only', filters=filters)
for vnf_pack in deleted_vnf_packages:
csar_zip_temp_path = (CONF.vnf_package.vnf_package_csar_path +
vnf_pack.id)
csar_path = (CONF.vnf_package.vnf_package_csar_path +
vnf_pack.id + '.zip')
try:
if os.path.exists(csar_zip_temp_path):
shutil.rmtree(csar_zip_temp_path)
os.remove(csar_path)
except OSError:
LOG.warning("Failed to delete csar zip %(zip)s and"
" folder $(folder)s for vnf package %(uuid)s.",
{'zip': csar_path, 'folder': csar_zip_temp_path,
'uuid': vnf_pack.id})
def _get_vnf_link_ports_by_vl(self, vnf_info, ext_vl_id,
resource_id):
results = []
vnf_vl_resource_info = vnf_info.vnf_virtual_link_resource_info
for vnf_vl_res in vnf_vl_resource_info:
if ((vnf_vl_res.vnf_virtual_link_desc_id == ext_vl_id) and
(vnf_vl_res.network_resource.resource_id != resource_id)):
results.extend(vnf_vl_res.vnf_link_ports)
return results
def _get_vnf_link_ports_by_cp(self, vnf_info, cpd_id=None):
vnf_vl_resource_info = vnf_info.vnf_virtual_link_resource_info
vnfc_resource_info = vnf_info.vnfc_resource_info
def _get_vnf_link_port(vnf_link_port_id):
for vnf_vl_res in vnf_vl_resource_info:
for vnf_link_port in vnf_vl_res.vnf_link_ports:
if vnf_link_port.id == vnf_link_port_id:
return vnf_link_port
results = []
for vnfc_resource in vnfc_resource_info:
for vnfc_cp_info in vnfc_resource.vnfc_cp_info:
if cpd_id == vnfc_cp_info.cpd_id:
results.append(
_get_vnf_link_port(vnfc_cp_info.vnf_link_port_id))
return results
@grant_error_common
def _change_ext_conn_grant(
self,
context,
vnf_instance,
change_ext_conn_req,
vnf_lcm_op_occ_id):
if not self._get_grant_execute():
return
vnf_inf = vnf_instance.instantiated_vnf_info
def _create_linkport_rd(linkport, cpd_id):
rh = linkport.resource_handle
rd = objects.ResourceDefinition()
rd.resource = objects.ResourceHandle()
rd.id = linkport.id
rd.type = constants.TYPE_LINKPORT
rd.resource_template_id = cpd_id
rd.resource.vim_connection_id = rh.vim_connection_id
rd.resource.resource_id = rh.resource_id
rd.resource.vim_level_resource_type = rh.vim_level_resource_type
return rd
def _get_cpd_id(cp_instance_id):
vnfc_resource_info = vnf_inf.vnfc_resource_info
for vnfc_resource in vnfc_resource_info:
for vnfc_cp_info in vnfc_resource.vnfc_cp_info:
if cp_instance_id == vnfc_cp_info.id:
return vnfc_cp_info.cpd_id
update_resources = dict()
# If network resource of the VirtualLink changed, get all LinkPort
# resource related to VirtualLink
for ext_vl in change_ext_conn_req.ext_virtual_links:
nw_changed_resources = self._get_vnf_link_ports_by_vl(
vnf_inf, ext_vl.id, ext_vl.resource_id)
LOG.debug('nw_changed_resources {}'.format(nw_changed_resources))
if nw_changed_resources:
for resource in nw_changed_resources:
cpd_id = _get_cpd_id(resource.cp_instance_id)
update_resources[resource.resource_handle.resource_id] = \
_create_linkport_rd(resource, cpd_id)
continue
# If network resource of the VirtualLink does not change,
# Searching vnfc_resource_info table by the cpd_id, if found, get
# LinkPort resource corresponding the CP.
# It does not check that the CP status updated or not.
for ext_cp in ext_vl.ext_cps:
cp_changed_resources = \
self._get_vnf_link_ports_by_cp(vnf_inf, ext_cp.cpd_id)
LOG.debug('cp_changed_resources {}'.format(
cp_changed_resources))
for resource in cp_changed_resources:
update_resources[resource.resource_handle.resource_id] = \
_create_linkport_rd(resource, ext_cp.cpd_id)
update_resources_list = list(update_resources.values())
LOG.debug("Update Resources: %s", update_resources_list)
grant_request = self._make_grant_request(
context,
vnf_instance,
vnf_lcm_op_occ_id,
'CHANGE_EXT_CONN',
False,
update_resources=update_resources_list)
return self._grant(context, grant_request)
def _grant(self, context, grant_request):
LOG.info(
"grant start grant_request[%s]" %
grant_request.to_request_body())
response = nfvo_client.GrantRequest().grants(
json=grant_request.to_request_body())
res_body = response.json()
res_dict = utils.convert_camelcase_to_snakecase(res_body)
LOG.info("grant end res_body[%s]" % res_dict)
grant_obj = objects.Grant.obj_from_primitive(
res_dict, context=context)
if len(grant_request.add_resources) != len(grant_obj.add_resources):
msg = "grant add resource error"
raise exceptions.ValidationError(detail=msg)
if len(
grant_request.remove_resources) != len(
grant_obj.remove_resources):
msg = "grant remove resource error"
raise exceptions.ValidationError(detail=msg)
if len(
grant_request.update_resources) != len(
grant_obj.update_resources):
msg = "grant update resource error"
raise exceptions.ValidationError(detail=msg)
self._check_res_add_remove_rsc(context, grant_request, grant_obj)
return grant_obj
def _check_res_add_remove_rsc(self, context, grant_request, grant_obj):
for add_resource in grant_request.add_resources:
match_flg = False
for rsc in grant_obj.add_resources:
if add_resource.id == rsc.resource_definition_id:
match_flg = True
break
if not match_flg:
msg = "grant add resource error"
raise exceptions.ValidationError(detail=msg)
for remove_resource in grant_request.remove_resources:
match_flg = False
for rsc in grant_obj.remove_resources:
if remove_resource.id == rsc.resource_definition_id:
match_flg = True
break
if not match_flg:
msg = "grant remove resource error"
raise exceptions.ValidationError(detail=msg)
for update_resource in grant_request.update_resources:
match_flg = False
for rsc in grant_obj.update_resources:
if update_resource.id == rsc.resource_definition_id:
match_flg = True
break
if not match_flg:
msg = "grant update resource error"
raise exceptions.ValidationError(detail=msg)
@grant_error_common
def _instantiate_grant(self,
context,
vnf_instance,
vnf_dict,
instantiate_vnf_request,
vnf_lcm_op_occ_id):
vnfd_dict = vnflcm_utils._get_vnfd_dict(context,
vnf_dict['vnfd']['id'],
instantiate_vnf_request.flavour_id)
inst_level = instantiate_vnf_request.instantiation_level_id
vnf_instance.instantiated_vnf_info = objects.InstantiatedVnfInfo(
flavour_id=instantiate_vnf_request.flavour_id,
instantiation_level_id=inst_level,
vnf_instance_id=vnf_instance.id)
vnf_instance.instantiated_vnf_info.reinitialize()
vnflcm_utils._build_instantiated_vnf_info(vnfd_dict,
instantiate_vnf_request, vnf_instance, '')
if not self._get_grant_execute():
return
add_resources = []
vnf_inf = vnf_instance.instantiated_vnf_info
for vnfc_resource in vnf_inf.vnfc_resource_info:
resource = objects.ResourceDefinition()
resource.id = vnfc_resource.id
resource.type = constants.TYPE_COMPUTE
resource.vdu_id = vnfc_resource.vdu_id
resource.resource_template_id = vnfc_resource.vdu_id
add_resources.append(resource)
for vl_resource in vnf_inf.vnf_virtual_link_resource_info:
resource = objects.ResourceDefinition()
resource.id = vl_resource.id
resource.type = constants.TYPE_VL
resource.resource_template_id = \
vl_resource.vnf_virtual_link_desc_id
add_resources.append(resource)
for cp_resource in vl_resource.vnf_link_ports:
for vnfc_resource in vnf_inf.vnfc_resource_info:
for vnfc_cp_resource in vnfc_resource.vnfc_cp_info:
if cp_resource.cp_instance_id == vnfc_cp_resource.id:
resource = objects.ResourceDefinition()
resource.id = cp_resource.id
resource.type = constants.TYPE_LINKPORT
resource.vdu_id = vnfc_resource.vdu_id
resource.resource_template_id = \
vnfc_cp_resource.cpd_id
add_resources.append(resource)
for storage_resource in vnf_inf.virtual_storage_resource_info:
for vnfc_resource in vnf_inf.vnfc_resource_info:
if storage_resource.id in vnfc_resource.storage_resource_ids:
resource = objects.ResourceDefinition()
resource.id = storage_resource.id
resource.type = constants.TYPE_STORAGE
resource.vdu_id = vnfc_resource.vdu_id
resource.resource_template_id = \
storage_resource.virtual_storage_desc_id
add_resources.append(resource)
p_c_list = []
placement_obj_list = []
topo_temp = vnfd_dict.get('topology_template', {})
for policy in topo_temp.get('policies', []):
affinity_type = {
'tosca.policies.nfv.AntiAffinityRule': 'ANTI_AFFINITY',
'tosca.policies.nfv.AffinityRule': 'AFFINITY'}
for policy_name, policy_dict in policy.items():
if policy_dict['type'] in affinity_type.keys():
placement_constraint = objects.PlacementConstraint()
key = policy_dict['type']
placement_constraint.affinity_or_anti_affinity = (
affinity_type[key])
placement_constraint.scope = 'ZONE'
placement_constraint.resource = []
placement_constraint.fallback_best_effort = True
for target in policy_dict.get('targets', []):
if target in topo_temp.get('groups', []):
for member in topo_temp['groups']['members']:
for vnfc_rsc in vnf_inf.vnfc_resource_info:
if member == vnfc_rsc.vdu_id:
resource = \
objects.ConstraintResourceRef()
resource.id_type = 'GRANT'
resource.resource_id = vnfc_rsc.id
p_rsc = \
placement_constraint.resource
p_rsc.append(resource)
break
else:
for vnfc_rsc in vnf_inf.vnfc_resource_info:
if target == vnfc_rsc.vdu_id:
resource = \
objects.ConstraintResourceRef()
resource.id_type = 'GRANT'
resource.resource_id = vnfc_rsc.id
p_rsc = placement_constraint.resource
p_rsc.append(resource)
break
p_c_list.append(placement_constraint)
placement_obj = models.PlacementConstraint()
placement_obj.id = uuidutils.generate_uuid()
placement_obj.vnf_instance_id = vnf_instance.id
placement_obj.affinity_or_anti_affinity = \
placement_constraint.affinity_or_anti_affinity
placement_obj.scope = placement_constraint.scope
placement_obj.server_group_name = policy_name
p_c_dict = placement_constraint.to_dict()
res_dict = p_c_dict.get('resource', {})
res_json = json.dumps(res_dict)
placement_obj.resource = res_json
placement_obj.created_at = timeutils.utcnow()
placement_obj.deleted_at = datetime.datetime.min
placement_obj_list.append(placement_obj)
g_request = self._make_grant_request(context,
vnf_instance,
vnf_lcm_op_occ_id,
'INSTANTIATE',
False,
add_resources=add_resources,
placement_constraints=p_c_list)
vnf_dict['placement_obj_list'] = placement_obj_list
vnf_dict['grant'] = self._grant(context, g_request)
def _get_placement(self, context, vnf_instance):
return self.vnfm_plugin.get_placement_constraint(context,
vnf_instance.id)
@grant_error_common
def _scale_grant(
self,
context,
vnf_dict,
vnf_instance,
scale_vnf_request,
vnf_lcm_op_occ_id):
# Check if vnf is in instantiated state.
vnf_instance = objects.VnfInstance.get_by_id(context,
vnf_instance.id)
if vnf_instance.instantiation_state == \
fields.VnfInstanceState.NOT_INSTANTIATED:
LOG.error("Scale action cannot be performed on vnf %(id)s "
"which is in %(state)s state.",
{"id": vnf_instance.id,
"state": vnf_instance.instantiation_state})
raise Exception("Scale action cannot be performed on vnf")
vim_info = vnflcm_utils._get_vim(
context, vnf_instance.vim_connection_info)
vim_connection_info = objects.VimConnectionInfo.obj_from_primitive(
vim_info, context)
if scale_vnf_request.type == 'SCALE_IN':
vnf_dict['action'] = 'in'
vnf_dict['policy_name'] = scale_vnf_request.aspect_id
reverse = scale_vnf_request.additional_params.get('is_reverse')
region_name = vim_connection_info.access_info.get('region_name')
scale_id_list, scale_name_list, grp_id, res_num = \
self.vnf_manager.invoke(vim_connection_info.vim_type,
'get_scale_in_ids',
plugin=self,
context=context,
vnf_dict=vnf_dict,
is_reverse=reverse,
auth_attr=vim_connection_info.access_info,
region_name=region_name,
number_of_steps=scale_vnf_request.number_of_steps)
vnf_dict['res_num'] = res_num
else:
scale_id_list = []
if not self._get_grant_execute():
return None, []
placement_obj_list = self.vnfm_plugin.get_placement_constraint(
context, vnf_instance.id)
self.vnf_manager.invoke(
vim_connection_info.vim_type,
'get_grant_resource',
plugin=self,
vnf_instance=vnf_instance,
vnf_info=vnf_dict,
scale_vnf_request=scale_vnf_request,
placement_obj_list=placement_obj_list,
vim_connection_info=vim_connection_info,
del_list=scale_id_list
)
vnf_dict['placement_obj_list'] = placement_obj_list
grant_request = self._make_grant_request(
context,
vnf_instance,
vnf_lcm_op_occ_id,
'SCALE',
False,
add_resources=vnf_dict['addResources'],
remove_resources=vnf_dict['removeResources'],
placement_constraints=vnf_dict['placement_constraint_list'])
vnf_dict['grant'] = self._grant(context, grant_request)
@grant_error_common
def _heal_grant(self,
context,
vnf_instance,
vnf_dict,
heal_vnf_request,
vnf_lcm_op_occ_id):
vnf_inf = vnf_instance.instantiated_vnf_info
if not self._get_grant_execute():
return
placement_obj_list = self._get_placement(context, vnf_instance)
vim_info = vnflcm_utils._get_vim(context,
vnf_instance.vim_connection_info)
vim_connection_info = \
objects.VimConnectionInfo.obj_from_primitive(vim_info, context)
cinder_list = self.vnf_manager.invoke(vim_connection_info.vim_type,
'get_cinder_list',
vnf_info=vnf_dict)
vnf_instantiated_info_after = copy.deepcopy(vnf_inf)
del_cre_vdu_list = []
add_resources = []
rm_resources = []
affinity_list = []
for vnfc_resource in vnf_instantiated_info_after.vnfc_resource_info:
vnfc_key = vnfc_resource.compute_resource.resource_id
if not heal_vnf_request.vnfc_instance_id or \
vnfc_key in heal_vnf_request.vnfc_instance_id:
if vnfc_resource.vdu_id not in del_cre_vdu_list:
del_cre_vdu_list.append(vnfc_resource.vdu_id)
for vnfc_resource in vnf_instantiated_info_after.vnfc_resource_info:
if vnfc_resource.vdu_id in del_cre_vdu_list:
resource = objects.ResourceDefinition()
resource.id = vnfc_resource.id
resource.type = constants.TYPE_COMPUTE
resource.vdu_id = vnfc_resource.vdu_id
resource.resource_template_id = vnfc_resource.vdu_id
vim_id = vnfc_resource.compute_resource.vim_connection_id
rsc_id = vnfc_resource.compute_resource.resource_id
vnfc_rh = objects.ResourceHandle(
vim_connection_id=vim_id,
resource_id=rsc_id)
resource.resource = vnfc_rh
rm_resources.append(resource)
add_uuid = uuidutils.generate_uuid()
resource = objects.ResourceDefinition()
resource.id = add_uuid
resource.type = constants.TYPE_COMPUTE
resource.vdu_id = vnfc_resource.vdu_id
resource.resource_template_id = vnfc_resource.vdu_id
add_resources.append(resource)
key_id = vnfc_resource.compute_resource.resource_id
for placement_obj in placement_obj_list:
resource_dict = jsonutils.loads(placement_obj.resource)
set_flg = False
for resource in resource_dict:
if resource.get('resource_id') == key_id:
resource['id_type'] = 'GRANT'
resource['resource_id'] = add_uuid
g_name = placement_obj.server_group_name
affinity_list.append(g_name)
set_flg = True
res_json = jsonutils.dump_as_bytes(resource_dict)
placement_obj.resource = res_json
break
if set_flg:
break
vnfc_resource.id = add_uuid
vnfc_resource.compute_resource = objects.ResourceHandle()
st_info = vnf_instantiated_info_after.virtual_storage_resource_info
for storage_resource in st_info:
if storage_resource.virtual_storage_desc_id in cinder_list:
for vnfc_resource in vnf_inf.vnfc_resource_info:
id_list = vnfc_resource.storage_resource_ids
if storage_resource.id in id_list:
resource = objects.ResourceDefinition()
resource.id = storage_resource.id
resource.type = constants.TYPE_STORAGE
resource.vdu_id = vnfc_resource.vdu_id
resource.resource_template_id = \
storage_resource.virtual_storage_desc_id
st_rh = objects.ResourceHandle()
st_rh.vim_connection_id = \
storage_resource.storage_resource.vim_connection_id
st_rh.resource_id = \
storage_resource.storage_resource.resource_id
resource.resource = st_rh
rm_resources.append(resource)
add_uuid = uuidutils.generate_uuid()
resource = objects.ResourceDefinition()
resource = objects.ResourceDefinition()
resource.id = add_uuid
resource.type = constants.TYPE_STORAGE
resource.vdu_id = vnfc_resource.vdu_id
resource.resource_template_id = \
storage_resource.virtual_storage_desc_id
add_resources.append(resource)
storage_resource.id = add_uuid
storage_resource.storage_resource = \
objects.ResourceHandle()
p_c_list = []
for placement_obj in placement_obj_list:
p_constraint = objects.PlacementConstraint()
p_constraint.affinity_or_anti_affinity = \
placement_obj.affinity_or_anti_affinity
p_constraint.scope = placement_obj.scope
resource_dict = jsonutils.loads(placement_obj.resource)
p_constraint.resource = []
for rsc in resource_dict:
rsc_obj = objects.ConstraintResourceRef()
rsc_obj.id_type = rsc.get('id_type')
rsc_obj.resource_id = rsc.get('resource_id')
p_constraint.resource.append(rsc_obj)
p_constraint.fallback_best_effort = True
p_c_list.append(p_constraint)
g_request = self._make_grant_request(context,
vnf_instance,
vnf_lcm_op_occ_id,
'HEAL',
False,
add_resources=add_resources,
remove_resources=rm_resources,
placement_constraints=p_c_list)
vnf_dict['placement_obj_list'] = placement_obj_list
vnf_dict['grant'] = self._grant(context, g_request)
vnf_dict['vnf_instantiated_info_after'] = vnf_instantiated_info_after
@grant_error_common
def _terminate_grant(self, context, vnf_instance, vnf_lcm_op_occ_id):
vnf_inf = vnf_instance.instantiated_vnf_info
if not self._get_grant_execute():
return
rm_resources = []
for vnfc_resource in vnf_inf.vnfc_resource_info:
resource = objects.ResourceDefinition()
resource.id = vnfc_resource.id
resource.type = constants.TYPE_COMPUTE
resource.vdu_id = vnfc_resource.vdu_id
resource.resource_template_id = vnfc_resource.vdu_id
vim_id = vnfc_resource.compute_resource.vim_connection_id
rsc_id = vnfc_resource.compute_resource.resource_id
vnfc_rh = objects.ResourceHandle(
vim_connection_id=vim_id,
resource_id=rsc_id)
resource.resource = vnfc_rh
rm_resources.append(resource)
for vl_resource in vnf_inf.vnf_virtual_link_resource_info:
resource = objects.ResourceDefinition()
resource.id = vl_resource.id
resource.type = constants.TYPE_VL
resource.resource_template_id = \
vl_resource.vnf_virtual_link_desc_id
vim_id = vl_resource.network_resource.vim_connection_id
rsc_id = vl_resource.network_resource.resource_id
vl_rh = objects.ResourceHandle(
vim_connection_id=vim_id,
resource_id=rsc_id)
resource.resource = vl_rh
rm_resources.append(resource)
for cp_resource in vl_resource.vnf_link_ports:
for vnfc_resource in vnf_inf.vnfc_resource_info:
for vnfc_cp_resource in vnfc_resource.vnfc_cp_info:
if cp_resource.cp_instance_id == vnfc_cp_resource.id:
resource = objects.ResourceDefinition()
resource.id = cp_resource.id
resource.type = constants.TYPE_LINKPORT
resource.vdu_id = vnfc_resource.vdu_id
resource.resource_template_id = \
vnfc_cp_resource.cpd_id
vim_id = \
cp_resource.resource_handle.vim_connection_id
rsc_id = cp_resource.resource_handle.resource_id
cp_rh = objects.ResourceHandle(
vim_connection_id=vim_id,
resource_id=rsc_id)
resource.resource = cp_rh
rm_resources.append(resource)
for storage_resource in vnf_inf.virtual_storage_resource_info:
for vnfc_resource in vnf_inf.vnfc_resource_info:
if storage_resource.id in vnfc_resource.storage_resource_ids:
resource = objects.ResourceDefinition()
resource.id = storage_resource.id
resource.type = constants.TYPE_STORAGE
resource.vdu_id = vnfc_resource.vdu_id
resource.resource_template_id = \
storage_resource.virtual_storage_desc_id
vim_id = \
storage_resource.storage_resource.vim_connection_id
rsc_id = storage_resource.storage_resource.resource_id
st_rh = objects.ResourceHandle(
vim_connection_id=vim_id,
resource_id=rsc_id)
resource.resource = st_rh
rm_resources.append(resource)
grant_request = self._make_grant_request(context,
vnf_instance,
vnf_lcm_op_occ_id,
'TERMINATE',
False,
remove_resources=rm_resources)
self._grant(context, grant_request)
def _get_grant_execute(self):
try:
nfvo_client.GrantRequest().validate()
except nfvo_client.UndefinedExternalSettingException:
return False
return True
def _make_grant_request(self, context, vnf_instance,
vnf_lcm_op_occ_id, operation,
is_automatic_invocation,
add_resources=[],
remove_resources=[],
update_resources=[],
placement_constraints=[]):
grant_request = objects.GrantRequest()
grant_request.vnf_instance_id = vnf_instance.id
grant_request.vnf_lcm_op_occ_id = vnf_lcm_op_occ_id
grant_request.vnfd_id = vnf_instance.vnfd_id
grant_request.flavour_id = \
vnf_instance.instantiated_vnf_info.flavour_id
grant_request.operation = operation
grant_request.is_automatic_invocation = is_automatic_invocation
vnflcm_url = CONF.vnf_lcm.endpoint_url + \
"/vnflcm/v1/vnf_lcm_op_occs/" + vnf_lcm_op_occ_id
insta_url = CONF.vnf_lcm.endpoint_url + \
"/vnflcm/v1/vnf_instances/" + vnf_instance.id
link_vnflcm = objects.Link(href=vnflcm_url)
link_insta = objects.Link(href=insta_url)
link = objects.Links(vnf_lcm_op_occ=link_vnflcm,
vnf_instance=link_insta)
grant_request._links = link
if add_resources:
grant_request.add_resources = add_resources
if remove_resources:
grant_request.remove_resources = remove_resources
if update_resources:
grant_request.update_resources = update_resources
if placement_constraints:
grant_request.placement_constraints = placement_constraints
return grant_request
def _create_placement(self, context, vnf_dict):
p_list = vnf_dict.get('placement_obj_list', [])
if len(p_list) == 0:
return
self.vnfm_plugin.create_placement_constraint(context,
p_list)
def _update_placement(self, context, vnf_dict, vnf_instance):
self.vnfm_plugin.update_placement_constraint_heal(
context, vnf_dict, vnf_instance)
def _delete_placement(self, context, vnf_instance_id):
self.vnfm_plugin.delete_placement_constraint(context,
vnf_instance_id)
@log.log
def _get_vnf_notify(self, context, id):
try:
vnf_notif = objects.VnfLcmOpOcc.get_by_id(context, id)
except exceptions.VnfInstanceNotFound:
error_msg = _("Can not find requested vnf instance: %s") % id
raise exceptions.NotificationProcessingError(error=error_msg)
except (sqlexc.SQLAlchemyError, Exception):
error_msg = _("Can not find requested vnf instance: %s") % id
raise exceptions.NotificationProcessingError(error=error_msg)
return vnf_notif
def _send_lcm_op_occ_notification(
self,
context,
vnf_lcm_op_occs_id,
old_vnf_instance,
vnf_instance,
request_obj,
**kwargs):
operation = kwargs.get('operation',
fields.LcmOccsOperationType.INSTANTIATE)
operation_state = kwargs.get('operation_state',
fields.LcmOccsOperationState.PROCESSING)
is_automatic_invocation = \
kwargs.get('is_automatic_invocation', False)
error = kwargs.get('error', None)
# Used for timing control when a failure occurs
error_point = kwargs.get('error_point', 0)
if old_vnf_instance:
vnf_instance_id = old_vnf_instance.id
else:
vnf_instance_id = vnf_instance.id
try:
LOG.debug("Update vnf lcm %s %s",
vnf_lcm_op_occs_id,
operation_state)
vnf_notif = self._get_vnf_notify(context, vnf_lcm_op_occs_id)
vnf_notif.operation_state = operation_state
if operation_state == fields.LcmOccsOperationState.FAILED_TEMP or \
operation_state == fields.LcmOccsOperationState.FAILED:
vnf_notif.error_point = error_point
error_details = objects.ProblemDetails(
context=context,
status=500,
detail=error
)
vnf_notif.error = error_details
vnf_notif.save()
except Exception:
error_msg = (
"Failed to update operation state of vnf instance %s" %
vnf_instance_id)
LOG.error(error_msg)
raise exceptions.NotificationProcessingError(error=error_msg)
# send notification
try:
notification_data = {
'notificationType':
fields.LcmOccsNotificationType.VNF_OP_OCC_NOTIFICATION,
'notificationStatus': fields.LcmOccsNotificationStatus.START,
'operationState': operation_state,
'vnfInstanceId': vnf_instance_id,
'operation': operation,
'isAutomaticInvocation': is_automatic_invocation,
'vnfLcmOpOccId': vnf_lcm_op_occs_id,
'_links': {
'vnfInstance': {
'href':
'/vnflcm/v1/vnf_instances/%s'
% vnf_instance_id},
'vnfLcmOpOcc': {
'href':
'/vnflcmv1/vnf_lcm_op_occs/%s'
% vnf_lcm_op_occs_id}}}
if(operation_state == fields.LcmOccsOperationState.COMPLETED or
operation_state == fields.LcmOccsOperationState.FAILED_TEMP or
operation_state == fields.LcmOccsOperationState.FAILED):
affected_resources = vnflcm_utils._get_affected_resources(
old_vnf_instance=old_vnf_instance,
new_vnf_instance=vnf_instance)
affected_resources_snake_case = \
utils.convert_camelcase_to_snakecase(affected_resources)
resource_change_obj = \
jsonutils.dumps(affected_resources_snake_case)
changed_resource = objects.ResourceChanges.obj_from_primitive(
resource_change_obj, context)
changed_ext_connectivity = \
vnflcm_utils._get_changed_ext_connectivity(
old_vnf_instance=old_vnf_instance,
new_vnf_instance=vnf_instance)
vnf_notif.resource_changes = changed_resource
vnf_notif.changed_ext_connectivity = changed_ext_connectivity
vnf_notif.save()
notification_data['affectedVnfcs'] = \
affected_resources.get('affectedVnfcs', [])
notification_data['affectedVirtualLinks'] = \
affected_resources.get('affectedVirtualLinks', [])
notification_data['affectedVirtualStorages'] = \
affected_resources.get('affectedVirtualStorages', [])
notification_data['notificationStatus'] = \
fields.LcmOccsNotificationStatus.RESULT
notification_data['changedExtConnectivity'] = \
utils.convert_snakecase_to_camelcase(
[i.to_dict() for i in changed_ext_connectivity])
if operation_state == \
fields.LcmOccsOperationState.FAILED_TEMP \
or operation_state == \
fields.LcmOccsOperationState.FAILED:
notification_data['error'] = error
# send notification
self.send_notification(context, notification_data)
except Exception as ex:
LOG.error(
"Failed to send notification {}. Details: {}".format(
vnf_lcm_op_occs_id, str(ex)))
def send_notification(self, context, notification):
"""Function to send notification to client
This function is used to send notification
to client during LCM Operation.
:returns: 0 if status code of the response is 204
-1 if vnf_lcm_subscriptions is not found in the DB
-2 if an Internal Server Error occurs
"""
try:
LOG.debug("send_notification start notification[%s]"
% notification)
notification = utils.convert_snakecase_to_camelcase(notification)
if (notification.get('notificationType') ==
'VnfLcmOperationOccurrenceNotification'):
vnf_lcm_subscriptions = \
objects.LccnSubscriptionRequest.vnf_lcm_subscriptions_get(
context,
operation_type=notification.get('operation'),
notification_type=notification.get('notificationType')
)
else:
vnf_lcm_subscriptions = \
objects.LccnSubscriptionRequest.vnf_lcm_subscriptions_get(
context,
notification_type=notification.get('notificationType')
)
if not vnf_lcm_subscriptions:
LOG.warn(
"vnf_lcm_subscription not found id[%s]" %
notification.get('vnfInstanceId'))
return -1
notification['id'] = uuidutils.generate_uuid()
# Notification shipping
for line in vnf_lcm_subscriptions:
notification['subscriptionId'] = line.id
if (notification.get('notificationType') ==
'VnfLcmOperationOccurrenceNotification'):
notification['_links']['subscription'] = {}
notification['_links']['subscription']['href'] = \
CONF.vnf_lcm.endpoint_url + \
"/vnflcm/v1/subscriptions/" + line.id
else:
notification['links']['subscription'] = {}
notification['links']['subscription']['href'] = \
CONF.vnf_lcm.endpoint_url + \
"/vnflcm/v1/subscriptions/" + line.id
notification['timeStamp'] = datetime.datetime.utcnow(
).isoformat()
try:
self.__set_auth_subscription(line)
for num in range(CONF.vnf_lcm.retry_num):
try:
LOG.info("send notify[%s]" %
json.dumps(notification))
auth_client = auth.auth_manager.get_auth_client(
notification['subscriptionId'])
response = auth_client.post(
line.callback_uri,
data=json.dumps(notification),
timeout=CONF.vnf_lcm.retry_timeout)
if response.status_code == 204:
LOG.info(
"send success notify[%s]",
json.dumps(notification))
break
else:
LOG.warning("Notification failed id[%s]"
" status[%s] callback_uri[%s]",
notification['id'], response.status_code,
line.callback_uri)
LOG.debug("retry_wait %s",
CONF.vnf_lcm.retry_wait)
self._retry_check(num)
continue
except requests.Timeout as e:
LOG.warning("Notification request timed out."
" id[%(id)s] callback_uri[%(uri)s]"
" reason[%(reason)s]", {
"id": notification['id'],
"uri": line.callback_uri,
"reason": str(e)})
self._retry_check(num)
except Exception as e:
LOG.warn("send error[%s]" % str(e))
LOG.warn(traceback.format_exc())
continue
except Exception as e:
LOG.warn("Internal Sever Error[%s]" % str(e))
LOG.warn(traceback.format_exc())
return -2
return 0
def _retry_check(self, retry_count):
time.sleep(CONF.vnf_lcm.retry_wait)
if retry_count == CONF.vnf_lcm.retry_num:
LOG.warn(
"Number of retries exceeded retry count [%s]" %
CONF.vnf_lcm.retry_num)
def test_notification(self, context, vnf_lcm_subscription=None):
"""Function to send test notification to client
This function is used to send test notification
to client during Register Subscription.
:returns: 0 if status code of the response is 204
or if CONF.vnf_lcm.test_callback_uri is False,
-1 if status code of the response is not 204
"""
if not CONF.vnf_lcm.test_callback_uri:
LOG.warning("Callback URI is %s", CONF.vnf_lcm.test_callback_uri)
return 0
# Notification shipping
for num in range(CONF.vnf_lcm.retry_num):
try:
auth_client = auth.auth_manager.get_auth_client(
vnf_lcm_subscription.id)
notification = {}
response = auth_client.get(
vnf_lcm_subscription.callback_uri,
data=json.dumps(notification),
timeout=CONF.vnf_lcm.retry_timeout)
if response.status_code == 204:
return 0
else:
LOG.warning(
"Notification failed status[%s] \
callback_uri[%s]" %
(response.status_code,
vnf_lcm_subscription.callback_uri))
LOG.debug(
"retry_wait %s" %
CONF.vnf_lcm.retry_wait)
self._retry_check(num)
continue
except requests.Timeout as e:
LOG.warning("Notification request timed out."
" callback_uri[%(uri)s]"
" reason[%(reason)s]", {
"uri": vnf_lcm_subscription.callback_uri,
"reason": str(e)})
self._retry_check(num)
# return -1 since the response is not 204
return -1
@coordination.synchronized('{vnf_instance[id]}')
def instantiate(
self,
context,
vnf_instance,
vnf_dict,
instantiate_vnf,
vnf_lcm_op_occs_id):
if vnf_dict['before_error_point'] == fields.ErrorPoint.INITIAL:
self._instantiate_grant(context,
vnf_instance,
vnf_dict,
instantiate_vnf,
vnf_lcm_op_occs_id)
try:
# Update vnf_lcm_op_occs table and send notification "PROCESSING"
self._send_lcm_op_occ_notification(
context=context,
vnf_lcm_op_occs_id=vnf_lcm_op_occs_id,
old_vnf_instance=None,
vnf_instance=vnf_instance,
request_obj=instantiate_vnf
)
vnf_dict['current_error_point'] = \
fields.ErrorPoint.NOTIFY_PROCESSING
if vnf_dict['before_error_point'] <= \
fields.ErrorPoint.NOTIFY_PROCESSING:
# change vnf_status
if vnf_dict['status'] == 'INACTIVE':
vnf_dict['status'] = 'PENDING_CREATE'
self._change_vnf_status(context, vnf_instance.id,
_INACTIVE_STATUS, 'PENDING_CREATE')
if vnf_dict['before_error_point'] <= \
fields.ErrorPoint.VNF_CONFIG_END:
self.vnflcm_driver.instantiate_vnf(context, vnf_instance,
vnf_dict, instantiate_vnf)
self._build_instantiated_vnf_info(context,
vnf_instance,
instantiate_vnf_req=instantiate_vnf)
self._update_vnf_attributes(context, vnf_instance, vnf_dict,
_PENDING_STATUS, _ACTIVE_STATUS)
vnf_dict['current_error_point'] = \
fields.ErrorPoint.NOTIFY_COMPLETED
self.vnflcm_driver._vnf_instance_update(context, vnf_instance,
instantiation_state=fields.VnfInstanceState.
INSTANTIATED, task_state=None)
self._create_placement(context, vnf_dict)
# Update vnf_lcm_op_occs table and send notification "COMPLETED"
self._send_lcm_op_occ_notification(
context=context,
vnf_lcm_op_occs_id=vnf_lcm_op_occs_id,
old_vnf_instance=None,
vnf_instance=vnf_instance,
request_obj=instantiate_vnf,
operation_state=fields.LcmOccsOperationState.COMPLETED
)
except Exception as ex:
if vnf_dict['current_error_point'] == \
fields.ErrorPoint.PRE_VIM_CONTROL:
if hasattr(vnf_instance.instantiated_vnf_info, 'instance_id'):
if vnf_instance.instantiated_vnf_info.instance_id:
vnf_dict['current_error_point'] = \
fields.ErrorPoint.POST_VIM_CONTROL
self._change_vnf_status(context, vnf_instance.id,
_ALL_STATUSES, 'ERROR')
self._build_instantiated_vnf_info(context, vnf_instance,
instantiate_vnf)
self.vnflcm_driver._vnf_instance_update(context, vnf_instance,
task_state=None)
# Update vnf_lcm_op_occs table and send notification "FAILED_TEMP"
self._send_lcm_op_occ_notification(
context=context,
vnf_lcm_op_occs_id=vnf_lcm_op_occs_id,
old_vnf_instance=None,
vnf_instance=vnf_instance,
request_obj=instantiate_vnf,
operation_state=fields.LcmOccsOperationState.FAILED_TEMP,
error=str(ex),
error_point=vnf_dict['current_error_point']
)
@coordination.synchronized('{vnf_instance[id]}')
def terminate(self, context, vnf_lcm_op_occs_id,
vnf_instance, terminate_vnf_req, vnf_dict):
if vnf_dict['before_error_point'] == fields.ErrorPoint.INITIAL:
self._terminate_grant(context,
vnf_instance,
vnf_lcm_op_occs_id)
try:
old_vnf_instance = copy.deepcopy(vnf_instance)
# Update vnf_lcm_op_occs table and send notification "PROCESSING"
self._send_lcm_op_occ_notification(
context=context,
vnf_lcm_op_occs_id=vnf_lcm_op_occs_id,
old_vnf_instance=old_vnf_instance,
vnf_instance=None,
request_obj=terminate_vnf_req,
operation=fields.LcmOccsOperationType.TERMINATE
)
vnf_dict['current_error_point'] = \
fields.ErrorPoint.NOTIFY_PROCESSING
if vnf_dict['before_error_point'] <= \
fields.ErrorPoint.NOTIFY_PROCESSING:
self._change_vnf_status(context, vnf_instance.id,
_ACTIVE_STATUS, 'PENDING_TERMINATE')
if vnf_dict['before_error_point'] <= \
fields.ErrorPoint.VNF_CONFIG_END:
self.vnflcm_driver.terminate_vnf(context, vnf_instance,
terminate_vnf_req, vnf_dict)
self._delete_placement(context, vnf_instance.id)
self._change_vnf_status(context, vnf_instance.id,
_PENDING_STATUS, 'INACTIVE')
vnf_dict['current_error_point'] = \
fields.ErrorPoint.NOTIFY_COMPLETED
self.vnflcm_driver._vnf_instance_update(context, vnf_instance,
vim_connection_info=[], task_state=None,
instantiation_state=fields.VnfInstanceState.NOT_INSTANTIATED)
vnf_instance.instantiated_vnf_info.reinitialize()
# Update vnf_lcm_op_occs table and send notification "COMPLETED"
self._send_lcm_op_occ_notification(
context=context,
vnf_lcm_op_occs_id=vnf_lcm_op_occs_id,
old_vnf_instance=old_vnf_instance,
vnf_instance=None,
request_obj=terminate_vnf_req,
operation=fields.LcmOccsOperationType.TERMINATE,
operation_state=fields.LcmOccsOperationState.COMPLETED
)
except Exception as exc:
# set vnf_status to error
self._change_vnf_status(context, vnf_instance.id,
_ALL_STATUSES, 'ERROR')
# Update vnf_lcm_op_occs table and send notification "FAILED_TEMP"
self._send_lcm_op_occ_notification(
context=context,
vnf_lcm_op_occs_id=vnf_lcm_op_occs_id,
old_vnf_instance=old_vnf_instance,
vnf_instance=None,
request_obj=terminate_vnf_req,
operation=fields.LcmOccsOperationType.TERMINATE,
operation_state=fields.LcmOccsOperationState.FAILED_TEMP,
error=str(exc),
error_point=vnf_dict['current_error_point']
)
@coordination.synchronized('{vnf_instance[id]}')
def heal(self,
context,
vnf_instance,
vnf_dict,
heal_vnf_request,
vnf_lcm_op_occs_id):
if vnf_dict['before_error_point'] == fields.ErrorPoint.INITIAL:
self._heal_grant(context,
vnf_instance,
vnf_dict,
heal_vnf_request,
vnf_lcm_op_occs_id)
try:
old_vnf_instance = copy.deepcopy(vnf_instance)
# Update vnf_lcm_op_occs table and send notification "PROCESSING"
self._send_lcm_op_occ_notification(
context=context,
vnf_lcm_op_occs_id=vnf_lcm_op_occs_id,
old_vnf_instance=old_vnf_instance,
vnf_instance=vnf_instance,
request_obj=heal_vnf_request,
operation=fields.LcmOccsOperationType.HEAL
)
vnf_dict['current_error_point'] = \
fields.ErrorPoint.NOTIFY_PROCESSING
if vnf_dict['before_error_point'] <= \
fields.ErrorPoint.NOTIFY_PROCESSING:
# update vnf status to PENDING_HEAL
self._change_vnf_status(context, vnf_instance.id,
_ACTIVE_STATUS, constants.PENDING_HEAL)
if vnf_dict['before_error_point'] <= \
fields.ErrorPoint.VNF_CONFIG_END:
self.vnflcm_driver.heal_vnf(context, vnf_instance,
vnf_dict, heal_vnf_request)
self._update_instantiated_vnf_info(context, vnf_instance,
heal_vnf_request)
# update instance_in in vnf_table
self._add_additional_vnf_info(context, vnf_instance)
# update vnf status to ACTIVE
self._change_vnf_status(context, vnf_instance.id,
_PENDING_STATUS, constants.ACTIVE)
vnf_dict['current_error_point'] = \
fields.ErrorPoint.NOTIFY_COMPLETED
# during .save() ,instantiated_vnf_info is also saved to DB
self.vnflcm_driver._vnf_instance_update(context, vnf_instance,
task_state=None)
self._update_placement(context, vnf_dict, vnf_instance)
# update vnf_lcm_op_occs and send notification "COMPLETED"
self._send_lcm_op_occ_notification(
context=context,
vnf_lcm_op_occs_id=vnf_lcm_op_occs_id,
old_vnf_instance=old_vnf_instance,
vnf_instance=vnf_instance,
request_obj=heal_vnf_request,
operation=fields.LcmOccsOperationType.HEAL,
operation_state=fields.LcmOccsOperationState.COMPLETED
)
except Exception as ex:
# update vnf_status to 'ERROR' and create event with 'ERROR' status
self._change_vnf_status(context, vnf_instance.id,
_ALL_STATUSES, constants.ERROR, str(ex))
# call _update_instantiated_vnf_info for notification
self._update_instantiated_vnf_info(context, vnf_instance,
heal_vnf_request)
# update vnf_lcm_op_occs and send notification "FAILED_TEMP"
self._send_lcm_op_occ_notification(
context=context,
vnf_lcm_op_occs_id=vnf_lcm_op_occs_id,
old_vnf_instance=old_vnf_instance,
vnf_instance=vnf_instance,
request_obj=heal_vnf_request,
operation=fields.LcmOccsOperationType.HEAL,
operation_state=fields.LcmOccsOperationState.FAILED_TEMP,
error=str(ex),
error_point=vnf_dict['current_error_point']
)
@coordination.synchronized('{vnf_instance[id]}')
def scale(self, context, vnf_info, vnf_instance, scale_vnf_request):
vnf_lcm_op_occ = vnf_info['vnf_lcm_op_occ']
vnf_lcm_op_occ_id = vnf_lcm_op_occ.id
if vnf_info['before_error_point'] == fields.ErrorPoint.INITIAL:
self._scale_grant(
context,
vnf_info,
vnf_instance,
scale_vnf_request,
vnf_lcm_op_occ_id)
self.vnflcm_driver.scale_vnf(
context, vnf_info, vnf_instance, scale_vnf_request)
def __set_auth_subscription(self, vnf_lcm_subscription):
def decode(val):
return val if isinstance(val, str) else val.decode()
if not vnf_lcm_subscription.subscription_authentication:
return
subscription_authentication = decode(
vnf_lcm_subscription.subscription_authentication)
authentication = utils.convert_camelcase_to_snakecase(
json.loads(subscription_authentication))
if not authentication:
return
auth_params = {}
auth_type = None
if 'params_basic' in authentication:
auth_params = authentication.get('params_basic')
auth_type = 'BASIC'
elif 'params_oauth2_client_credentials' in authentication:
auth_params = authentication.get(
'params_oauth2_client_credentials')
auth_type = 'OAUTH2_CLIENT_CREDENTIALS'
auth.auth_manager.set_auth_client(
id=decode(vnf_lcm_subscription.id),
auth_type=auth_type,
auth_params=auth_params)
@revert_update_lcm
def update(
self,
context,
vnf_lcm_opoccs,
body_data,
vnfd_pkg_data,
vnfd_id):
# input vnf_lcm_op_occs
now = timeutils.utcnow()
lcm_op_obj = objects.vnf_lcm_op_occs.VnfLcmOpOcc(context=context)
lcm_op_obj.id = vnf_lcm_opoccs.get('id')
lcm_op_obj.operation_state = fields.LcmOccsOperationState.PROCESSING
lcm_op_obj.state_entered_time = vnf_lcm_opoccs.get(
'state_entered_time')
lcm_op_obj.start_time = now
lcm_op_obj.vnf_instance_id = vnf_lcm_opoccs.get('vnf_instance_id')
lcm_op_obj.operation = fields.InstanceOperation.MODIFY_INFO
lcm_op_obj.is_automatic_invocation = 0
lcm_op_obj.is_cancel_pending = 0
lcm_op_obj.operationParams = vnf_lcm_opoccs.get('operationParams')
try:
lcm_op_obj.create()
except Exception as msg:
raise Exception(str(msg))
# Notification
instance_url = self._get_vnf_instance_href(
vnf_lcm_opoccs.get('vnf_instance_id'))
lcm_url = self._get_vnf_lcm_op_occs_href(vnf_lcm_opoccs.get('id'))
notification_data = {
'notificationType':
fields.LcmOccsNotificationType.VNF_OP_OCC_NOTIFICATION,
'notificationStatus': fields.LcmOccsNotificationStatus.START,
'operationState': fields.LcmOccsOperationState.PROCESSING,
'vnfInstanceId': vnf_lcm_opoccs.get('vnf_instance_id'),
'operation': fields.InstanceOperation.MODIFY_INFO,
'isAutomaticInvocation': False,
'vnfLcmOpOccId': vnf_lcm_opoccs.get('id'),
'_links': {
'vnfInstance': {
'href': instance_url},
'vnfLcmOpOcc': {
'href': lcm_url}}}
self.send_notification(context, notification_data)
# update vnf_instances
try:
ins_obj = objects.vnf_instance.VnfInstance(context=context)
result = ins_obj.update(
context,
vnf_lcm_opoccs,
body_data,
vnfd_pkg_data,
vnfd_id)
except Exception as msg:
raise Exception(str(msg))
# update lcm_op_occs
if vnfd_pkg_data and len(vnfd_pkg_data) > 0:
changed_info = \
objects.vnf_lcm_op_occs.VnfInfoModifications._from_dict(
vnfd_pkg_data)
else:
changed_info = objects.vnf_lcm_op_occs.VnfInfoModifications()
changed_info.vnf_instance_name = body_data.get('vnf_instance_name')
changed_info.vnf_instance_description = body_data.get(
'vnf_instance_description')
# update vnf_lcm_op_occs
now = timeutils.utcnow()
lcm_op_obj.id = vnf_lcm_opoccs.get('id')
lcm_op_obj.operation_state = fields.LcmOccsOperationState.COMPLETED
lcm_op_obj.state_entered_time = result
lcm_op_obj.updated_at = now
lcm_op_obj.changed_info = changed_info
try:
lcm_op_obj.save()
except Exception as msg:
raise Exception(str(msg))
# Notification
notification_data['notificationStatus'] = 'RESULT'
notification_data['operationState'] = 'COMPLETED'
notification_data['changed_info'] = changed_info.to_dict()
self.send_notification(context, notification_data)
@coordination.synchronized('{vnf_instance[id]}')
def rollback(self, context, vnf_info, vnf_instance, operation_params):
self.vnflcm_driver.rollback_vnf(context, vnf_info,
vnf_instance, operation_params)
@coordination.synchronized('{vnf_instance[id]}')
def change_ext_conn(
self,
context,
vnf_instance,
vnf_dict,
change_ext_conn_req,
vnf_lcm_op_occs_id):
"""Perform change external VNF connectivity operation.
This function will support changing external VNF connectivity
as defined in ETSI NFV SOL 002 and SOL 003, but now, you can
specify changing fixedAddresses or numDynamicAddresses in
ipAddresses attribute in extVirtualLinks.
Note:
1. Get grant from NFVO(if needed).
Request grant information is made from ExtVirtualLinkData
of ChangeExtConnRequest. If ExtVirtualLinkInfo is changed
from instantiated VNF, we inform VnfLinkPortInfo related
to that ExtVirtualLinkInfo. Also, we inform VnfLinkPortInfo
related to each individual VnfExtCpInfo.
2. Call vnflcm_driver to change networks.
Invoke vnflcm_driver to perform change external VNF
connectivity.
3. Update VNF information
Update InstantiatedVnfInfo as a post-processing.
Args:
context (Context): context for security/db session.
vnf_instance (VnfInstance): Information object for VNF instance.
vnf_dict (dict): Container for error point indication.
change_ext_conn_req (ChangeExtConnRequest):
Request object of change external connectivity.
vnf_lcm_op_occs_id (uuid): self-explanatory :)
"""
if vnf_dict['before_error_point'] == EP.INITIAL:
self._change_ext_conn_grant(
context,
vnf_instance,
change_ext_conn_req,
vnf_lcm_op_occs_id)
try:
old_vnf_instance = copy.deepcopy(vnf_instance)
# Update vnf_lcm_op_occs table and send notification "PROCESSING"
self._send_lcm_op_occ_notification(
context=context,
vnf_lcm_op_occs_id=vnf_lcm_op_occs_id,
old_vnf_instance=None,
vnf_instance=vnf_instance,
request_obj=change_ext_conn_req,
operation=fields.LcmOccsOperationType.CHANGE_EXT_CONN
)
vnf_dict['current_error_point'] = EP.NOTIFY_PROCESSING
if vnf_dict['before_error_point'] <= EP.NOTIFY_PROCESSING:
# update vnf status to PENDING_CHANGE_EXT_CONN
self._change_vnf_status(context, vnf_instance.id,
_ACTIVE_STATUS, 'PENDING_CHANGE_EXT_CONN')
self.vnflcm_driver.change_ext_conn_vnf(
context,
vnf_instance,
vnf_dict,
change_ext_conn_req)
vnf_dict['current_error_point'] = EP.NOTIFY_COMPLETED
self._update_instantiated_vnf_info_change_ext_conn(
context, vnf_instance, change_ext_conn_req)
# update vnf status to ACTIVE
self._update_vnf_attributes(context, vnf_instance, vnf_dict,
_PENDING_STATUS, _ACTIVE_STATUS)
# Update vnf_lcm_op_occs table and send notification "COMPLETED"
self._send_lcm_op_occ_notification(
context=context,
vnf_lcm_op_occs_id=vnf_lcm_op_occs_id,
old_vnf_instance=old_vnf_instance,
vnf_instance=vnf_instance,
request_obj=change_ext_conn_req,
operation=fields.LcmOccsOperationType.CHANGE_EXT_CONN,
operation_state=fields.LcmOccsOperationState.COMPLETED
)
except Exception as e:
# update vnf_status to 'ERROR' and create event with 'ERROR' status
self._change_vnf_status(context, vnf_instance.id,
_ALL_STATUSES, constants.ERROR, str(e))
LOG.error('Failed to execute operation. error={}'.format(e))
if vnf_dict['current_error_point'] in [EP.INTERNAL_PROCESSING,
EP.VNF_CONFIG_END]:
self._update_instantiated_vnf_info_change_ext_conn(
context, vnf_instance, change_ext_conn_req)
# update vnf_lcm_op_occs and send notification "FAILED_TEMP"
self._send_lcm_op_occ_notification(
context=context,
vnf_lcm_op_occs_id=vnf_lcm_op_occs_id,
old_vnf_instance=old_vnf_instance,
vnf_instance=vnf_instance,
request_obj=change_ext_conn_req,
operation=fields.LcmOccsOperationType.CHANGE_EXT_CONN,
operation_state=fields.LcmOccsOperationState.FAILED_TEMP,
error=str(e),
error_point=vnf_dict['current_error_point']
)
def init(args, **kwargs):
CONF(args=args, project='tacker',
version='%%prog %s' % version.version_info.release_string(),
**kwargs)
# FIXME(ihrachys): if import is put in global, circular import
# failure occurs
from tacker.common import rpc as n_rpc
n_rpc.init(CONF)
def main(manager='tacker.conductor.conductor_server.Conductor'):
init(sys.argv[1:])
objects.register_all()
logging.setup(CONF, "tacker")
oslo_messaging.set_transport_defaults(control_exchange='tacker')
logging.setup(CONF, "tacker")
CONF.log_opt_values(LOG, logging.DEBUG)
server = tacker_service.Service.create(
binary='tacker-conductor',
topic=topics.TOPIC_CONDUCTOR,
manager=manager)
service.launch(CONF, server, restart_method='mutate').wait()