Add heal vnf instance API

Implemented heal vnf instance API.
* POST /vnflcm/v1/vnf_instances/{vnf_instance_id}/heal}

Co-authored-By: Ajay Parja <ajay.parja@nttdata.com>
Co-authored-By: Nitin Uikey <nitin.uikey@nttdata.com>
Co-authored-By: Shubham Potale <shubham.potale@nttdata.com>

Change-Id: I38bdac64a8a3eb3f8880085b5a77db97e5a1a8f2
Blueprint: support-etsi-nfv-specs
changes/03/707803/38
tpatil 3 years ago
parent fbb38266d6
commit b4f357f2b3
  1. 16
      tacker/api/schemas/vnf_lcm.py
  2. 34
      tacker/api/vnflcm/v1/controller.py
  3. 7
      tacker/api/vnflcm/v1/router.py
  4. 4
      tacker/common/exceptions.py
  5. 3
      tacker/conductor/conductor_server.py
  6. 11
      tacker/conductor/conductorrpc/vnf_lcm_rpc.py
  7. 18
      tacker/objects/heal_vnf_request.py
  8. 202
      tacker/objects/instantiate_vnf_req.py
  9. 11
      tacker/policies/vnf_lcm.py
  10. 15
      tacker/tests/unit/conductor/test_conductor_server.py
  11. 282
      tacker/tests/unit/objects/test_instantiate_vnf_req.py
  12. 137
      tacker/tests/unit/vnflcm/test_controller.py
  13. 270
      tacker/tests/unit/vnflcm/test_vnflcm_driver.py
  14. 312
      tacker/tests/unit/vnfm/infra_drivers/openstack/test_openstack_driver.py
  15. 122
      tacker/vnflcm/vnflcm_driver.py
  16. 31
      tacker/vnfm/infra_drivers/abstract_driver.py
  17. 11
      tacker/vnfm/infra_drivers/kubernetes/kubernetes_driver.py
  18. 11
      tacker/vnfm/infra_drivers/noop.py
  19. 157
      tacker/vnfm/infra_drivers/openstack/openstack.py

@ -210,3 +210,19 @@ terminate = {
'required': ['terminationType'],
'additionalProperties': False,
}
heal = {
'type': 'object',
'properties': {
'cause': {'type': 'string', 'maxLength': 255},
'vnfcInstanceId': {
'type': 'array',
"items": {
"type": "string",
'format': 'uuid'
}
}
},
'additionalProperties': False,
}

@ -269,8 +269,40 @@ class VnfLcmController(wsgi.Controller):
vnf_instance = self._get_vnf_instance(context, id)
self._terminate(context, vnf_instance, body)
@check_vnf_state(action="heal",
instantiation_state=[fields.VnfInstanceState.INSTANTIATED],
task_state=[None])
def _heal(self, context, vnf_instance, request_body):
req_body = utils.convert_camelcase_to_snakecase(request_body)
heal_vnf_request = objects.HealVnfRequest(context=context, **req_body)
inst_vnf_info = vnf_instance.instantiated_vnf_info
vnfc_resource_info_ids = [vnfc_resource_info.id for
vnfc_resource_info in inst_vnf_info.vnfc_resource_info]
for vnfc_id in heal_vnf_request.vnfc_instance_id:
# check if vnfc_id exists in vnfc_resource_info
if vnfc_id not in vnfc_resource_info_ids:
msg = _("Vnfc id %(vnfc_id)s not present in vnf instance "
"%(id)s")
raise webob.exc.HTTPBadRequest(
explanation=msg % {"vnfc_id": vnfc_id,
"id": vnf_instance.id})
vnf_instance.task_state = fields.VnfInstanceTaskState.HEALING
vnf_instance.save()
self.rpc_api.heal(context, vnf_instance, heal_vnf_request)
@wsgi.response(http_client.ACCEPTED)
@wsgi.expected_errors((http_client.BAD_REQUEST, http_client.FORBIDDEN,
http_client.NOT_FOUND, http_client.CONFLICT))
@validation.schema(vnf_lcm.heal)
def heal(self, request, id, body):
raise webob.exc.HTTPNotImplemented()
context = request.environ['tacker.context']
context.can(vnf_lcm_policies.VNFLCM % 'heal')
vnf_instance = self._get_vnf_instance(context, id)
self._heal(context, vnf_instance, body)
def create_resource():

@ -70,6 +70,13 @@ class VnflcmAPIRouter(wsgi.Router):
"/vnf_instances/{id}/instantiate",
methods, controller, default_resource)
# Allowed methods on
# /vnflcm/v1/vnf_instances/{vnfInstanceId}/heal resource
methods = {"POST": "heal"}
self._setup_route(mapper,
"/vnf_instances/{id}/heal",
methods, controller, default_resource)
# Allowed methods on
# /vnflcm/v1/vnf_instances/{vnfInstanceId}/terminate resource
methods = {"POST": "terminate"}

@ -266,6 +266,10 @@ class VnfPreInstantiationFailed(TackerException):
"%(error)s")
class VnfHealFailed(TackerException):
message = _("Heal Vnf failed for vnf %(id)s, error: %(error)s")
class OrphanedObjectError(TackerException):
msg_fmt = _('Cannot call %(method)s on orphaned %(objtype)s object')

@ -438,6 +438,9 @@ class Conductor(manager.Manager):
LOG.error("Failed to update usage_state of vnf package %s",
vnf_package.id)
def heal(self, context, vnf_instance, heal_vnf_request):
self.vnflcm_driver.heal_vnf(context, vnf_instance, heal_vnf_request)
def init(args, **kwargs):
CONF(args=args, project='tacker',

@ -49,3 +49,14 @@ class VNFLcmRPCAPI(object):
return rpc_method(context, 'terminate',
vnf_instance=vnf_instance,
terminate_vnf_req=terminate_vnf_req)
def heal(self, context, vnf_instance, heal_vnf_request, cast=True):
serializer = objects_base.TackerObjectSerializer()
client = rpc.get_client(self.target, version_cap=None,
serializer=serializer)
cctxt = client.prepare()
rpc_method = cctxt.cast if cast else cctxt.call
return rpc_method(context, 'heal',
vnf_instance=vnf_instance,
heal_vnf_request=heal_vnf_request)

@ -13,6 +13,8 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo_utils import versionutils
from tacker.objects import base
from tacker.objects import fields
@ -33,10 +35,20 @@ class HealVnfAdditionalParams(base.TackerObject):
class HealVnfRequest(base.TackerObject):
# Version 1.0: Initial version
VERSION = '1.0'
# Version 1.1: Added vnf_instance_id
VERSION = '1.1'
fields = {
'cause': fields.StringField(),
'vnfc_instance_id': fields.ListOfStringsField(nullable=True,
default=[]),
'cause': fields.StringField(nullable=True, default=None),
'additional_params': fields.ListOfObjectsField(
'HealVnfAdditionalParams')
'HealVnfAdditionalParams', default=[])
}
def obj_make_compatible(self, primitive, target_version):
super(HealVnfRequest, self).obj_make_compatible(primitive,
target_version)
target_version = versionutils.convert_version_to_tuple(target_version)
if target_version < (1, 1) and 'vnfc_instance_id' in primitive:
del primitive['vnfc_instance_id']

@ -22,6 +22,176 @@ from tacker.objects import fields
LOG = logging.getLogger(__name__)
def _get_vim_connection_info(vnf_instance):
vim_connection_infos = []
for vim_conn_info in vnf_instance.vim_connection_info:
new_vim_conn_info = vim_conn_info.obj_clone()
vim_connection_infos.append(new_vim_conn_info)
return vim_connection_infos
def _get_ext_managed_virtual_links(vnf_instantiated_info):
ext_managed_virtual_links = []
for ext_mng_vl_info in \
vnf_instantiated_info.ext_managed_virtual_link_info:
network_resource = ext_mng_vl_info.network_resource
ext_mng_vl_data = objects.ExtManagedVirtualLinkData(
id=ext_mng_vl_info.id,
vnf_virtual_link_desc_id=ext_mng_vl_info.vnf_virtual_link_desc_id,
resource_id=network_resource.resource_id)
ext_managed_virtual_links.append(ext_mng_vl_data)
return ext_managed_virtual_links
def _get_cp_instance_id(ext_virtual_link_info_id, vnf_instantiated_info):
cp_instances = []
for vnf_vl_res_info in \
vnf_instantiated_info.vnf_virtual_link_resource_info:
if ext_virtual_link_info_id == \
vnf_vl_res_info.vnf_virtual_link_desc_id:
for vnf_link_port in vnf_vl_res_info.vnf_link_ports:
cp_instances.append(vnf_link_port.cp_instance_id)
return cp_instances
def _get_cp_data_from_vnfc_resource_info(cp_instance_list,
vnf_instantiated_info):
vnfc_cp_infos = []
for vnfc_resource_info in vnf_instantiated_info.vnfc_resource_info:
for vnfc_cp_info in vnfc_resource_info.vnfc_cp_info:
if vnfc_cp_info.id in cp_instance_list:
vnfc_cp_infos.append(vnfc_cp_info)
return vnfc_cp_infos
def _get_link_ports(vnfc_cp_info_list, vnf_instantiated_info):
ext_link_ports = []
for vnfc_cp_info in vnfc_cp_info_list:
for ext_vl_info in vnf_instantiated_info.ext_virtual_link_info:
for ext_vl_port in ext_vl_info.ext_link_ports:
if ext_vl_port.id != vnfc_cp_info.vnf_ext_cp_id:
continue
resource_handle = ext_vl_port.resource_handle.obj_clone()
ext_link_port_data = objects.ExtLinkPortData(
id=ext_vl_port.id,
resource_handle=resource_handle)
ext_link_ports.append(ext_link_port_data)
break
return ext_link_ports
def _get_cp_protocol_data_list(ext_cp_info):
cp_protocol_data_list = []
def _get_ip_addresses(ip_addresses):
ip_addresses = []
for ip_address in ip_addresses:
# TODO(nitin-uikey): How to determine num_dynamic_addresses
# back from InstantiatedVnfInfo->IpAddress.
ip_address_data = IpAddress(
type=ip_address.type,
subnet_id=ip_address.subnet_id,
fixed_addresses=ip_address.addresses)
ip_addresses.append(ip_address_data)
return ip_addresses
for cp_protocol_info in ext_cp_info.cp_protocol_info:
if cp_protocol_info.ip_over_ethernet:
ip_addresses = _get_ip_addresses(cp_protocol_info.
ip_over_ethernet.ip_addresses)
ip_over_ethernet_data = objects.IpOverEthernetAddressData(
mac_address=cp_protocol_info.ip_over_ethernet.mac_address,
ip_addresses=ip_addresses)
else:
ip_over_ethernet_data = None
cp_protocol_data = objects.CpProtocolData(
layer_protocol=cp_protocol_info.layer_protocol,
ip_over_ethernet=ip_over_ethernet_data)
cp_protocol_data_list.append(cp_protocol_data)
return cp_protocol_data_list
def _get_cp_ids(vnfc_cp_info_list, vnf_instantiated_info):
ext_cps = []
for vnfc_cp_info in vnfc_cp_info_list:
for ext_cp_info in vnf_instantiated_info.ext_cp_info:
if ext_cp_info.cpd_id != vnfc_cp_info.cpd_id:
continue
ext_cp_configs = []
vnf_ext_cp_data = objects.VnfExtCpData()
vnf_ext_cp_data.cpd_id = ext_cp_info.cpd_id
cp_protocol_data_list = _get_cp_protocol_data_list(ext_cp_info)
# TODO(nitin-uikey) set cp_instance_id
# and prepare 1-N objects of VnfExtCpConfig
vnf_ext_cp_config = objects.VnfExtCpConfig(
link_port_id=vnfc_cp_info.vnf_ext_cp_id,
cp_protocol_data=cp_protocol_data_list)
ext_cp_configs.append(vnf_ext_cp_config)
vnf_ext_cp_data = objects.VnfExtCpData(
cpd_id=ext_cp_info.cpd_id,
cp_config=ext_cp_configs)
ext_cps.append(vnf_ext_cp_data)
break
return ext_cps
def _get_ext_virtual_link_data(vnf_instantiated_info):
ext_virtual_links = []
for ext_vl_info in \
vnf_instantiated_info.ext_virtual_link_info:
resource_handle = ext_vl_info.resource_handle
ext_vl_data = objects.ExtVirtualLinkData(
id=ext_vl_info.id,
resource_id=resource_handle.resource_id)
# call vnf virtual link resource info
cp_instances = _get_cp_instance_id(ext_vl_info.id,
vnf_instantiated_info)
# get cp info from vnfcresources
vnfc_cp_infos = _get_cp_data_from_vnfc_resource_info(cp_instances,
vnf_instantiated_info)
ext_vl_data.ext_link_ports = _get_link_ports(vnfc_cp_infos,
vnf_instantiated_info)
# assign the data to extcp info and link port
ext_vl_data.ext_cps = _get_cp_ids(vnfc_cp_infos,
vnf_instantiated_info)
ext_virtual_links.append(ext_vl_data)
return ext_virtual_links
@base.TackerObjectRegistry.register
class InstantiateVnfRequest(base.TackerObject):
# Version 1.0: Initial version
@ -87,6 +257,38 @@ class InstantiateVnfRequest(base.TackerObject):
ext_virtual_links=ext_virtual_links,
additional_params=additional_params)
@classmethod
def from_vnf_instance(cls, vnf_instance):
vnf_instantiated_info = vnf_instance.instantiated_vnf_info
# Vim connection info
vim_connection_info = _get_vim_connection_info(vnf_instance)
# Flavour id
flavour_id = vnf_instantiated_info.flavour_id
# Instantiation level
instantiation_level_id = vnf_instantiated_info.instantiation_level_id
# Externally managed virtual links
ext_managed_virtual_links = _get_ext_managed_virtual_links(
vnf_instantiated_info)
# External virtual links
ext_virtual_links = _get_ext_virtual_link_data(vnf_instantiated_info)
additional_params = vnf_instantiated_info.additional_params
instantiate_vnf_request = cls(flavour_id=flavour_id,
instantiation_level_id=instantiation_level_id,
ext_managed_virtual_links=ext_managed_virtual_links,
vim_connection_info=vim_connection_info,
ext_virtual_links=ext_virtual_links,
additional_params=additional_params)
return instantiate_vnf_request
@base.TackerObjectRegistry.register
class ExtManagedVirtualLinkData(base.TackerObject):

@ -65,6 +65,17 @@ rules = [
'path': '/vnflcm/v1/vnf_instances/{vnfInstanceId}/terminate'
}
]
),
policy.DocumentedRuleDefault(
name=VNFLCM % 'heal',
check_str=base.RULE_ADMIN_OR_OWNER,
description="Heal a VNF instance.",
operations=[
{
'method': 'POST',
'path': '/vnflcm/v1/vnf_instances/{vnfInstanceId}/heal'
}
]
)
]

@ -342,6 +342,21 @@ class TestConductor(SqlTestCase):
mock_log.error.assert_called_once_with(expected_msg,
vnf_package_vnfd.package_uuid)
def test_heal_vnf_instance(self):
vnf_package_vnfd = self._create_and_upload_vnf_package()
vnf_instance_data = fake_obj.get_vnf_instance_data(
vnf_package_vnfd.vnfd_id)
vnf_instance = objects.VnfInstance(context=self.context,
**vnf_instance_data)
vnf_instance.create()
vnf_instance.instantiation_state = \
fields.VnfInstanceState.INSTANTIATED
vnf_instance.save()
heal_vnf_req = objects.HealVnfRequest(cause="healing request")
self.conductor.heal(self.context, vnf_instance, heal_vnf_req)
self.vnflcm_driver.heal_vnf.assert_called_once_with(
self.context, mock.ANY, heal_vnf_req)
@mock.patch.object(os, 'remove')
@mock.patch.object(shutil, 'rmtree')
@mock.patch.object(os.path, 'exists')

@ -0,0 +1,282 @@
# Copyright (c) 2020 NTT DATA
#
# 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.
from tacker import context
from tacker import objects
from tacker.objects import fields
from tacker.tests.unit import base
from tacker.tests import uuidsentinel
def get_instantiated_info_dict_for_ext_links_and_flavour_id():
return {"instantiated_vnf_info": {
"additional_params": {'key1': 'value1'},
"vnfc_resource_info": [{
"vdu_id": "VDU1",
"vnfc_cp_info": [{
"cp_protocol_info": [{
"ip_over_ethernet": {
"mac_address": "fa:16:3e:0d:6f:71"},
"layer_protocol": "IP_OVER_ETHERNET"}],
"vnf_ext_cp_id": None,
"cpd_id": "CP1",
"vnf_link_port_id": "a41417d8-5cba-4256-aa4a-c68b79bb2dc2",
"id": "350ab5d7-7cf0-4d24-aa2f-ec7e51149d56"}, {
"cp_protocol_info": [{
"layer_protocol": "IP_OVER_ETHERNET"}],
"vnf_ext_cp_id": "413f4e46-21cf-41b1-be0f-de8d23f76cfe",
"cpd_id": "CP2",
"vnf_link_port_id": "b5f67448-87ee-4250-ad8b-514bc693f6c4",
"id": "2cab54a3-8ac5-4338-b586-b12e4ff1a89f"}, {
"vnf_link_port_id": "124f1923-9de1-4729-8d4e-bc0613066dc4",
"id": "b3341e7b-20bb-4ae5-8be9-b00cf79a9395",
"vnf_ext_cp_id": None,
"cpd_id": "CP3"}],
"compute_resource": {
"vim_level_resource_type": "OS::Nova::Server",
"resource_id": "c83ac219-376a-4016-b8b2-50c3707f71c4"},
"id": "0688be82-05a6-4b00-b869-d4719baf4f42",
"storage_resource_ids": [],
"metadata": {}}],
"ext_virtual_link_info": [{
"resource_handle": {
"vim_level_resource_type": None,
"resource_id": "7ec01a11-e584-404a-88bd-39a56b63e29c"},
"id": "net0"}, {
"resource_handle": {
"vim_level_resource_type": None,
"resource_id": "dc67ee99-e963-44e2-a152-f0fb492eae76"},
"id": "external_network",
"ext_link_ports": [{
"cp_instance_id": "f47a9e33-b31a-4290-828a-c7569c52bd0e",
"resource_handle": {
"vim_level_resource_type": "LINKPORT",
"resource_id": "67f7e772-0d31-4087-bf4c-2576fadcbdb7"},
"id": "413f4e46-21cf-41b1-be0f-de8d23f76cfe"}]}],
"vnf_virtual_link_resource_info": [{
"vnf_link_ports": [{
"cp_instance_id": "b3341e7b-20bb-4ae5-8be9-b00cf79a9395",
"resource_handle": {
"vim_level_resource_type": "OS::Neutron::Port",
"resource_id": "87b567a0-783a-4c06-b0d8-cdafd40c51e3"},
"id": "124f1923-9de1-4729-8d4e-bc0613066dc4"}],
"network_resource": {
"vim_level_resource_type": "OS::Neutron::Net",
"resource_id": "413f4e46-21cf-41b1-be0f-de8d23f76cfd"},
"vnf_virtual_link_desc_id": "VL3",
"id": "84ffa547-1164-4e60-863d-c7dac770f824"}, {
"vnf_link_ports": [{
"cp_instance_id": "2cab54a3-8ac5-4338-b586-b12e4ff1a89f",
"resource_handle": {
"vim_level_resource_type": "OS::Neutron::Port",
"resource_id": "413f4e46-21cf-41b1-be0f-de8d23f76cfe"},
"id": "b5f67448-87ee-4250-ad8b-514bc693f6c4"}],
"network_resource": {
"vim_level_resource_type": "OS::Neutron::Net",
"resource_id": "dc67ee99-e963-44e2-a152-f0fb492eae76"},
"vnf_virtual_link_desc_id": "external_network",
"id": "1050cce6-27ca-40df-b66e-160113fc4826"}, {
"vnf_link_ports": [{
"cp_instance_id": "350ab5d7-7cf0-4d24-aa2f-ec7e51149d56",
"resource_handle": {
"vim_level_resource_type": "OS::Neutron::Port",
"resource_id": "2bca5538-edd6-4590-ab1a-552ae7d0f81b"},
"id": "a41417d8-5cba-4256-aa4a-c68b79bb2dc2"}],
"network_resource": {
"vim_level_resource_type": "OS::Neutron::Net",
"resource_id": "7ec01a11-e584-404a-88bd-39a56b63e29c"},
"vnf_virtual_link_desc_id": "net0",
"id": "5ad98d4d-4b81-4b1b-a88b-1f64b66e151b"}],
"ext_managed_virtual_link_info": [{
"network_resource": {
"vim_level_resource_type": "OS::Neutron::Net",
"resource_id": "413f4e46-21cf-41b1-be0f-de8d23f76cfd"},
"id": "net1",
"vnf_link_ports": [{
"cp_instance_id": "b3341e7b-20bb-4ae5-8be9-b00cf79a9395",
"resource_handle": {
"vim_level_resource_type": "OS::Neutron::Port",
"resource_id": "87b567a0-783a-4c06-b0d8-cdafd40c51e3"},
"id": "124f1923-9de1-4729-8d4e-bc0613066dc4"}],
"vnf_virtual_link_desc_id": "VL3"}],
"flavour_id": "simple",
"vnf_state": "STARTED",
"ext_cp_info": [{
"cp_protocol_info": [{
"ip_over_ethernet": {
"mac_address": "fa:16:3e:0d:6f:71"},
"layer_protocol": "IP_OVER_ETHERNET"}],
"cpd_id": "CP1",
"id": "19f0aa71-9376-43dc-8e13-5e76e4bdc8bf",
"ext_link_port_id": None}, {
"cp_protocol_info": [{
"layer_protocol": "IP_OVER_ETHERNET"}],
"cpd_id": "CP2",
"id": "f47a9e33-b31a-4290-828a-c7569c52bd0e",
"ext_link_port_id": None}]
}
}
class InstantiateVnfRequestTestCase(base.TestCase):
def setUp(self):
super(InstantiateVnfRequestTestCase, self).setUp()
self.context = context.get_admin_context()
def _create_vim_connection_info(self, **kwargs):
vim_connection_info = objects.VimConnectionInfo(**kwargs)
return [vim_connection_info]
def _create_vnf_instance(self, vim_connection_info=None):
vnf_instance = objects.VnfInstance(
context=self.context,
vnf_instance_name="Sample vnf instance name",
vnf_instance_description="Sample vnf instance description",
vnfd_id=uuidsentinel.vnfd_id,
instantiation_state=fields.VnfInstanceState.INSTANTIATED,
vnf_provider='Company',
vnf_product_name='Sample VNF',
vnf_software_version='1.0',
vnfd_version='1.0',
tenant_id=uuidsentinel.tenant_id)
if vim_connection_info:
vnf_instance.vim_connection_info = vim_connection_info
return vnf_instance
def test_from_vnf_instance_with_flavour(self):
"""Map flavour id"""
inst_vnf_request = objects.InstantiateVnfRequest(flavour_id="simple")
instantiated_vnf_info = objects.InstantiatedVnfInfo(
flavour_id="simple")
vnf_instance = self._create_vnf_instance()
vnf_instance.instantiated_vnf_info = instantiated_vnf_info
inst_vnf_request_actual = objects.InstantiateVnfRequest.\
from_vnf_instance(vnf_instance)
self.compare_obj(inst_vnf_request, inst_vnf_request_actual)
def test_from_vnf_instance_with_flavour_and_instantiation_level(self):
"""Map flavour id and instantiation level"""
inst_vnf_request = objects.InstantiateVnfRequest(flavour_id="simple",
instantiation_level_id="instantiation_level_1")
instantiated_vnf_info = objects.InstantiatedVnfInfo(
flavour_id="simple",
instantiation_level_id="instantiation_level_1")
vnf_instance = self._create_vnf_instance()
vnf_instance.instantiated_vnf_info = instantiated_vnf_info
inst_vnf_request_actual = objects.InstantiateVnfRequest.\
from_vnf_instance(vnf_instance)
self.compare_obj(inst_vnf_request, inst_vnf_request_actual)
def test_from_vnf_instance_with_ext_vl_and_ext_managed_vl(self):
"""Map external and internal network information.
Map following information:
a) ext_virtual_link_info
b) ext_managed_virtual_link_info
"""
ext_vl_info = [{
"ext_cps": [{
"cp_config": [{
"cp_protocol_data": [{
"ip_over_ethernet": {
"mac_address": "fa:16:3e:0d:6f:71"},
"layer_protocol": "IP_OVER_ETHERNET"}]}],
"cpd_id": "CP1"}],
"id": "net0",
"resource_id": "7ec01a11-e584-404a-88bd-39a56b63e29c"}, {
"ext_cps": [{
"cp_config": [{
"cp_protocol_data": [{
"layer_protocol": "IP_OVER_ETHERNET"}],
"link_port_id": "413f4e46-21cf-41b1-be0f-de8d23f76cfe"}],
"cpd_id": "CP2"}],
"ext_link_ports": [{
"id": "413f4e46-21cf-41b1-be0f-de8d23f76cfe",
"resource_handle": {
"resource_id": "67f7e772-0d31-4087-bf4c-2576fadcbdb7",
"vim_level_resource_type": "LINKPORT"}}],
"id": "external_network",
"resource_id": "dc67ee99-e963-44e2-a152-f0fb492eae76"}]
ext_mg_vl = {"id": "net1",
"resource_id": "413f4e46-21cf-41b1-be0f-de8d23f76cfd",
"vnf_virtual_link_desc_id": "VL3"}
vim_connection_info = [{
"id": "6b0ff598-60d6-49b4-a907-a1111de52d92",
"vim_id": uuidsentinel.vim_id,
"vim_type": "ETSINFV.OPENSTACK_KEYSTONE.v_2",
"access_info": {}}]
vnf_info_data = {'ext_managed_virtual_links': [ext_mg_vl],
'ext_virtual_links': ext_vl_info,
'vim_connection_info': vim_connection_info,
'flavour_id': 'simple',
'additional_params': {'key1': 'value1'}}
inst_vnf_request = objects.InstantiateVnfRequest.obj_from_primitive(
vnf_info_data, self.context)
response = get_instantiated_info_dict_for_ext_links_and_flavour_id()
instantiated_vnf_info_dict = response.get('instantiated_vnf_info')
instantiated_vnf_info = objects.InstantiatedVnfInfo.obj_from_primitive(
instantiated_vnf_info_dict, self.context)
vnf_instance = self._create_vnf_instance(
self._create_vim_connection_info(**vim_connection_info[0]))
vnf_instance.instantiated_vnf_info = instantiated_vnf_info
inst_vnf_req_actual = objects.InstantiateVnfRequest.from_vnf_instance(
vnf_instance)
self.assertEqual(inst_vnf_request.flavour_id,
inst_vnf_req_actual.flavour_id)
self.assertEqual(inst_vnf_request.instantiation_level_id,
inst_vnf_req_actual.instantiation_level_id)
self.assertEqual(inst_vnf_request.additional_params,
inst_vnf_req_actual.additional_params)
for expected, actual in zip(inst_vnf_request.ext_managed_virtual_links,
inst_vnf_req_actual.ext_managed_virtual_links):
self.compare_obj(expected, actual)
for expected, actual in zip(inst_vnf_request.ext_virtual_links,
inst_vnf_req_actual.ext_virtual_links):
self.assertEqual(expected.id, actual.id)
self.assertEqual(expected.resource_id, actual.resource_id)
for expected, actual in zip(inst_vnf_request.vim_connection_info,
inst_vnf_req_actual.vim_connection_info):
self.assertEqual(expected.id, actual.id)
self.assertEqual(expected.vim_id, actual.vim_id)
self.assertEqual(expected.vim_type, actual.vim_type)

@ -835,3 +835,140 @@ class TestController(base.TestCase):
"terminate while the vnf instance is in this state.")
self.assertEqual(expected_msg % uuidsentinel.vnf_instance_id,
resp.json['conflictingRequest']['message'])
@mock.patch.object(objects.VnfInstance, "get_by_id")
@mock.patch.object(objects.VnfInstance, "save")
@mock.patch.object(VNFLcmRPCAPI, "heal")
@ddt.data({'cause': 'healing'}, {})
def test_heal(self, body, mock_rpc_heal, mock_save,
mock_vnf_by_id):
vnf_instance_obj = fakes.return_vnf_instance(
fields.VnfInstanceState.INSTANTIATED)
mock_vnf_by_id.return_value = vnf_instance_obj
req = fake_request.HTTPRequest.blank(
'/vnf_instances/%s/heal' % uuidsentinel.vnf_instance_id)
req.body = jsonutils.dump_as_bytes(body)
req.headers['Content-Type'] = 'application/json'
req.method = 'POST'
resp = req.get_response(self.app)
self.assertEqual(http_client.ACCEPTED, resp.status_code)
mock_rpc_heal.assert_called_once()
def test_heal_cause_max_length_exceeded(self):
body = {'cause': 'A' * 256}
req = fake_request.HTTPRequest.blank(
'/vnf_instances/%s/heal' % uuidsentinel.vnf_instance_id)
req.body = jsonutils.dump_as_bytes(body)
req.headers['Content-Type'] = 'application/json'
req.method = 'POST'
resp = req.get_response(self.app)
self.assertEqual(http_client.BAD_REQUEST, resp.status_code)
@mock.patch.object(objects.VnfInstance, "get_by_id")
def test_heal_incorrect_instantiated_state(self, mock_vnf_by_id):
vnf_instance_obj = fakes.return_vnf_instance(
fields.VnfInstanceState.NOT_INSTANTIATED)
mock_vnf_by_id.return_value = vnf_instance_obj
body = {}
req = fake_request.HTTPRequest.blank(
'/vnf_instances/%s/heal' % uuidsentinel.vnf_instance_id)
req.body = jsonutils.dump_as_bytes(body)
req.headers['Content-Type'] = 'application/json'
req.method = 'POST'
resp = req.get_response(self.app)
self.assertEqual(http_client.CONFLICT, resp.status_code)
expected_msg = ("Vnf instance %s in instantiation_state "
"NOT_INSTANTIATED. Cannot heal while the vnf instance "
"is in this state.")
self.assertEqual(expected_msg % uuidsentinel.vnf_instance_id,
resp.json['conflictingRequest']['message'])
@mock.patch.object(objects.VnfInstance, "get_by_id")
def test_heal_incorrect_task_state(self, mock_vnf_by_id):
vnf_instance_obj = fakes.return_vnf_instance(
fields.VnfInstanceState.INSTANTIATED,
task_state=fields.VnfInstanceTaskState.HEALING)
mock_vnf_by_id.return_value = vnf_instance_obj
body = {}
req = fake_request.HTTPRequest.blank(
'/vnf_instances/%s/heal' % uuidsentinel.vnf_instance_id)
req.body = jsonutils.dump_as_bytes(body)
req.headers['Content-Type'] = 'application/json'
req.method = 'POST'
resp = req.get_response(self.app)
self.assertEqual(http_client.CONFLICT, resp.status_code)
expected_msg = ("Vnf instance %s in task_state "
"HEALING. Cannot heal while the vnf instance "
"is in this state.")
self.assertEqual(expected_msg % uuidsentinel.vnf_instance_id,
resp.json['conflictingRequest']['message'])
@mock.patch.object(objects.VnfInstance, "get_by_id")
def test_heal_with_invalid_vnfc_id(self, mock_vnf_by_id):
vnf_instance_obj = fakes.return_vnf_instance(
fields.VnfInstanceState.INSTANTIATED)
mock_vnf_by_id.return_value = vnf_instance_obj
body = {'vnfcInstanceId': [uuidsentinel.vnfc_instance_id]}
req = fake_request.HTTPRequest.blank(
'/vnf_instances/%s/heal' % uuidsentinel.vnf_instance_id)
req.body = jsonutils.dump_as_bytes(body)
req.headers['Content-Type'] = 'application/json'
req.method = 'POST'
resp = req.get_response(self.app)
self.assertEqual(http_client.BAD_REQUEST, resp.status_code)
expected_msg = "Vnfc id %s not present in vnf instance %s"
self.assertEqual(expected_msg % (uuidsentinel.vnfc_instance_id,
uuidsentinel.vnf_instance_id), resp.json['badRequest']['message'])
@ddt.data('HEAD', 'PUT', 'DELETE', 'PATCH', 'GET')
def test_heal_invalid_http_method(self, method):
body = {}
req = fake_request.HTTPRequest.blank(
'/vnf_instances/%s/heal' % uuidsentinel.vnf_instance_id)
req.body = jsonutils.dump_as_bytes(body)
req.headers['Content-Type'] = 'application/json'
req.method = method
resp = req.get_response(self.app)
self.assertEqual(http_client.METHOD_NOT_ALLOWED, resp.status_code)
@ddt.data({'attribute': 'cause', 'value': 123,
'expected_type': 'string'},
{'attribute': 'cause', 'value': True,
'expected_type': 'string'},
{'attribute': 'vnfcInstanceId', 'value': 123,
'expected_type': 'array'},
{'attribute': 'vnfcInstanceId', 'value': True,
'expected_type': 'array'},
)
@ddt.unpack
def test_heal_with_invalid_request_body(
self, attribute, value, expected_type):
body = {}
req = fake_request.HTTPRequest.blank(
'/vnf_instances/29c770a3-02bc-4dfc-b4be-eb173ac00567/heal')
body.update({attribute: value})
req.body = jsonutils.dump_as_bytes(body)
req.headers['Content-Type'] = 'application/json'
req.method = 'POST'
exception = self.assertRaises(
exceptions.ValidationError, self.controller.heal,
req, body=body)
expected_message = \
("Invalid input for field/attribute {attribute}. Value: {value}. "
"{value} is not of type '{expected_type}'".
format(value=value, attribute=attribute,
expected_type=expected_type))
self.assertEqual(expected_message, exception.msg)

@ -59,7 +59,7 @@ class FakeDriverManager(mock.Mock):
if self.fail_method_name and \
self.fail_method_name == 'create_wait':
raise InfraDriverException("create_wait failed")
if 'post_vnf_instantiation' in args:
elif 'post_vnf_instantiation' in args:
pass
if 'delete' in args:
if self.fail_method_name and \
@ -73,6 +73,18 @@ class FakeDriverManager(mock.Mock):
if self.fail_method_name and \
self.fail_method_name == 'delete_vnf_resource':
raise InfraDriverException("delete_vnf_resource failed")
elif 'heal_vnf' in args:
if self.fail_method_name and \
self.fail_method_name == 'heal_vnf':
raise InfraDriverException("heal_vnf failed")
elif 'heal_vnf_wait' in args:
if self.fail_method_name and \
self.fail_method_name == 'heal_vnf_wait':
raise InfraDriverException("heal_vnf_wait failed")
elif 'post_heal_vnf' in args:
if self.fail_method_name and \
self.fail_method_name == 'post_heal_vnf':
raise InfraDriverException("post_heal_vnf failed")
class FakeVimClient(mock.Mock):
@ -439,3 +451,259 @@ class TestVnflcmDriver(db_base.SqlTestCase):
self.assertEqual("delete_vnf_resource failed", str(error))
self.assertEqual(2, mock_vnf_instance_save.call_count)
self.assertEqual(3, self._vnf_manager.invoke.call_count)
@mock.patch.object(objects.VnfPackageVnfd, 'get_by_id')
@mock.patch.object(vim_client.VimClient, "get_vim")
@mock.patch.object(objects.VnfResource, "create")
@mock.patch.object(objects.VnfResource, "destroy")
@mock.patch.object(objects.VnfResourceList, "get_by_vnf_instance_id")
@mock.patch.object(objects.VnfInstance, "save")
@mock.patch('tacker.vnflcm.vnflcm_driver.LOG')
def test_heal_vnf_without_vnfc_instance(self, mock_log, mock_save,
mock_vnf_resource_list, mock_resource_destroy,
mock_resource_create, mock_vim, mock_vnf_package_vnfd):
vnf_package_vnfd = fakes.return_vnf_package_vnfd()
vnf_package_id = vnf_package_vnfd.package_uuid
mock_vnf_package_vnfd.return_value = vnf_package_vnfd
fake_csar = os.path.join(self.temp_dir, vnf_package_id)
cfg.CONF.set_override('vnf_package_csar_path', self.temp_dir,
group='vnf_package')
base_path = os.path.dirname(os.path.abspath(__file__))
sample_vnf_package_zip = os.path.join(
base_path, "../../etc/samples/sample_vnf_package_csar.zip")
extracted_zip_path = fake_csar
zipfile.ZipFile(sample_vnf_package_zip, 'r').extractall(
extracted_zip_path)
mock_vnf_resource_list.return_value = [fakes.return_vnf_resource()]
# Heal as per SOL003 i.e. without vnfcInstanceId
heal_vnf_req = objects.HealVnfRequest()
vim_obj = {'vim_id': uuidsentinel.vim_id,
'vim_name': 'fake_vim',
'vim_type': 'openstack',
'vim_auth': {
'auth_url': 'http://localhost/identity',
'password': 'test_pw',
'username': 'test_user',
'project_name': 'test_project'}}
mock_vim.return_value = vim_obj
vnf_instance = fakes.return_vnf_instance(
fields.VnfInstanceState.INSTANTIATED)
vnf_instance.instantiated_vnf_info.instance_id =\
uuidsentinel.instance_id
self._mock_vnf_manager()
driver = vnflcm_driver.VnfLcmDriver()
driver.heal_vnf(self.context, vnf_instance, heal_vnf_req)
self.assertEqual(1, mock_save.call_count)
# vnf resource software images will be deleted during
# deleting vnf instance.
self.assertEqual(1, mock_resource_destroy.call_count)
# Vnf resource software images will be created during
# instantiation.
self.assertEqual(1, mock_resource_create.call_count)
# Invoke will be called 7 times, 3 for deleting the vnf
# resources and 4 during instantiation.
self.assertEqual(7, self._vnf_manager.invoke.call_count)
expected_msg = ("Request received for healing vnf '%s' "
"is completed successfully")
mock_log.info.assert_called_with(expected_msg,
vnf_instance.id)
shutil.rmtree(fake_csar)
@mock.patch.object(objects.VnfInstance, "save")
@mock.patch('tacker.vnflcm.vnflcm_driver.LOG')
def test_heal_vnf_without_vnfc_instance_infra_delete_fail(self, mock_log,
mock_save):
# Heal as per SOL003 i.e. without vnfcInstanceId
heal_vnf_req = objects.HealVnfRequest()
vnf_instance = fakes.return_vnf_instance(
fields.VnfInstanceState.INSTANTIATED)
vnf_instance.instantiated_vnf_info.instance_id =\
uuidsentinel.instance_id
self._mock_vnf_manager(fail_method_name='delete')
driver = vnflcm_driver.VnfLcmDriver()
self.assertRaises(exceptions.VnfHealFailed,
driver.heal_vnf, self.context, vnf_instance, heal_vnf_req)
self.assertEqual(1, mock_save.call_count)
self.assertEqual(1, self._vnf_manager.invoke.call_count)
self.assertEqual(fields.VnfInstanceTaskState.ERROR,
vnf_instance.task_state)
expected_msg = ('Failed to delete vnf resources for vnf instance %s '
'before respawning. The vnf is in inconsistent '
'state. Error: delete failed')
mock_log.error.assert_called_with(expected_msg % vnf_instance.id)
@mock.patch.object(objects.VnfPackageVnfd, 'get_by_id')
@mock.patch.object(vim_client.VimClient, "get_vim")
@mock.patch.object(objects.VnfResource, "create")
@mock.patch.object(objects.VnfResource, "destroy")
@mock.patch.object(objects.VnfResourceList, "get_by_vnf_instance_id")
@mock.patch.object(objects.VnfInstance, "save")
@mock.patch('tacker.vnflcm.vnflcm_driver.LOG')
def test_heal_vnf_without_vnfc_instance_infra_instantiate_vnf_fail(self,
mock_log, mock_save, mock_vnf_resource_list,
mock_resource_destroy, mock_resource_create, mock_vim,
mock_vnf_package_vnfd):
vnf_package_vnfd = fakes.return_vnf_package_vnfd()
vnf_package_id = vnf_package_vnfd.package_uuid
mock_vnf_package_vnfd.return_value = vnf_package_vnfd
fake_csar = os.path.join(self.temp_dir, vnf_package_id)
cfg.CONF.set_override('vnf_package_csar_path', self.temp_dir,
group='vnf_package')
base_path = os.path.dirname(os.path.abspath(__file__))
sample_vnf_package_zip = os.path.join(
base_path, "../../etc/samples/sample_vnf_package_csar.zip")
extracted_zip_path = fake_csar
zipfile.ZipFile(sample_vnf_package_zip, 'r').extractall(
extracted_zip_path)
mock_vnf_resource_list.return_value = [fakes.return_vnf_resource()]
# Heal as per SOL003 i.e. without vnfcInstanceId
heal_vnf_req = objects.HealVnfRequest()
vnf_instance = fakes.return_vnf_instance(
fields.VnfInstanceState.INSTANTIATED)
vnf_instance.instantiated_vnf_info.instance_id =\
uuidsentinel.instance_id
self._mock_vnf_manager(fail_method_name='instantiate_vnf')
driver = vnflcm_driver.VnfLcmDriver()
self.assertRaises(exceptions.VnfHealFailed,
driver.heal_vnf, self.context, vnf_instance, heal_vnf_req)
self.assertEqual(1, mock_save.call_count)
# vnf resource software images will be deleted during
# deleting vnf instance.
self.assertEqual(1, mock_resource_destroy.call_count)
# Vnf resource software images will be created during
# instantiation.
self.assertEqual(1, mock_resource_create.call_count)
self.assertEqual(5, self._vnf_manager.invoke.call_count)
self.assertEqual(fields.VnfInstanceTaskState.ERROR,
vnf_instance.task_state)
expected_msg = ('Failed to instantiate vnf instance %s '
'after termination. The vnf is in inconsistent '
'state. Error: Vnf instantiation failed for vnf %s, '
'error: instantiate_vnf failed')
mock_log.error.assert_called_with(expected_msg % (vnf_instance.id,
vnf_instance.id))
@mock.patch.object(objects.VnfInstance, "save")
@mock.patch('tacker.vnflcm.vnflcm_driver.LOG')
def test_heal_vnf_with_vnfc_instance(self, mock_log, mock_save):
heal_vnf_req = objects.HealVnfRequest(vnfc_instance_id=[
uuidsentinel.vnfc_instance_id_1])
vnf_instance = fakes.return_vnf_instance(
fields.VnfInstanceState.INSTANTIATED,
task_state=fields.VnfInstanceTaskState.HEALING)
self._mock_vnf_manager()
driver = vnflcm_driver.VnfLcmDriver()
driver.heal_vnf(self.context, vnf_instance, heal_vnf_req)
self.assertEqual(1, mock_save.call_count)
self.assertEqual(3, self._vnf_manager.invoke.call_count)
self.assertEqual(None, vnf_instance.task_state)
expected_msg = ("Request received for healing vnf '%s' "
"is completed successfully")
mock_log.info.assert_called_with(expected_msg,
vnf_instance.id)
@mock.patch.object(objects.VnfInstance, "save")
@mock.patch('tacker.vnflcm.vnflcm_driver.LOG')
def test_heal_vnf_with_infra_heal_vnf_fail(self, mock_log, mock_save):
heal_vnf_req = objects.HealVnfRequest(vnfc_instance_id=[
uuidsentinel.vnfc_instance_id_1])
vnf_instance = fakes.return_vnf_instance(
fields.VnfInstanceState.INSTANTIATED,
task_state=fields.VnfInstanceTaskState.HEALING)
self._mock_vnf_manager(fail_method_name='heal_vnf')
driver = vnflcm_driver.VnfLcmDriver()
self.assertRaises(exceptions.VnfHealFailed,
driver.heal_vnf, self.context, vnf_instance,
heal_vnf_req)
self.assertEqual(1, mock_save.call_count)
self.assertEqual(1, self._vnf_manager.invoke.call_count)
self.assertEqual(fields.VnfInstanceTaskState.ERROR,
vnf_instance.task_state)
expected_msg = ("Failed to heal vnf %(id)s in infra driver. "
"Error: %(error)s")
mock_log.error.assert_called_with(expected_msg,
{'id': vnf_instance.id, 'error': 'heal_vnf failed'})
@mock.patch.object(objects.VnfInstance, "save")
@mock.patch('tacker.vnflcm.vnflcm_driver.LOG')
def test_heal_vnf_with_infra_heal_vnf_wait_fail(self, mock_log,
mock_save):
heal_vnf_req = objects.HealVnfRequest(vnfc_instance_id=[
uuidsentinel.vnfc_instance_id_1])
vnf_instance = fakes.return_vnf_instance(
fields.VnfInstanceState.INSTANTIATED,
task_state=fields.VnfInstanceTaskState.HEALING)
vnf_instance.instantiated_vnf_info.instance_id =\
uuidsentinel.instance_id
self._mock_vnf_manager(fail_method_name='heal_vnf_wait')
driver = vnflcm_driver.VnfLcmDriver()
# It won't raise any exception if infra driver raises
# heal_vnf_wait because there is a possibility the vnfc
# resources could go into inconsistent state so it would
# proceed further and call post_heal_vnf with a hope
# it will work and vnflcm can update the vnfc resources
# properly and hence the _vnf_manager.invoke.call_count
# should be 3 instead of 2.
driver.heal_vnf(self.context, vnf_instance, heal_vnf_req)
self.assertEqual(1, mock_save.call_count)
self.assertEqual(3, self._vnf_manager.invoke.call_count)
self.assertEqual(None, vnf_instance.task_state)
expected_msg = ('Failed to update vnf %(id)s resources for '
'instance%(instance)s. Error: %(error)s')
mock_log.error.assert_called_with(expected_msg,
{'id': vnf_instance.id,
'instance': vnf_instance.instantiated_vnf_info.instance_id,
'error': 'heal_vnf_wait failed'})
@mock.patch.object(objects.VnfInstance, "save")
@mock.patch('tacker.vnflcm.vnflcm_driver.LOG')
def test_heal_vnf_with_infra_post_heal_vnf_fail(self, mock_log,
mock_save):
heal_vnf_req = objects.HealVnfRequest(vnfc_instance_id=[
uuidsentinel.vnfc_instance_id_1])
vnf_instance = fakes.return_vnf_instance(
fields.VnfInstanceState.INSTANTIATED,
task_state=fields.VnfInstanceTaskState.HEALING)
vnf_instance.instantiated_vnf_info.instance_id =\
uuidsentinel.instance_id
self._mock_vnf_manager(fail_method_name='post_heal_vnf')
driver = vnflcm_driver.VnfLcmDriver()
self.assertRaises(exceptions.VnfHealFailed,
driver.heal_vnf, self.context, vnf_instance, heal_vnf_req)
self.assertEqual(1, mock_save.call_count)
self.assertEqual(3, self._vnf_manager.invoke.call_count)
self.assertEqual(fields.VnfInstanceTaskState.ERROR,
vnf_instance.task_state)
expected_msg = ('Failed to store updated resources information for '
'instance %(instance)s for vnf %(id)s. '
'Error: %(error)s')
mock_log.error.assert_called_with(expected_msg,
{'instance': vnf_instance.instantiated_vnf_info.instance_id,
'id': vnf_instance.id,
'error': 'post_heal_vnf failed'})

@ -22,6 +22,7 @@ import tempfile
from tacker.common import exceptions
from tacker import context
from tacker.extensions import vnfm
from tacker import objects
from tacker.tests.common import helpers
from tacker.tests.unit import base
from tacker.tests.unit.db import utils
@ -77,6 +78,39 @@ class TestOpenStack(base.FixturedTestCase):
self.requests_mock.register_uri('GET', url, json=json,
headers=self.json_headers)
def _response_in_stack_get(self, id, stack_status='CREATE_COMPLETE'):
# response for heat_client's stack_get()
url = self.heat_url + '/stacks/' + id
json = {'stack': fd_utils.get_dummy_stack(status=stack_status)}
self.requests_mock.register_uri('GET', url, json=json,
headers=self.json_headers)
def _response_in_stack_update(self, id):
# response for heat_client's stack_patch()
url = self.heat_url + '/stacks/' + id
self.requests_mock.register_uri('PATCH', url,
headers=self.json_headers)
def _response_resource_mark_unhealthy(self, id, resources,
raise_exception=False):
# response for heat_client's heatclient.resource_mark_unhealthy
if not resources:
return
class MyException(Exception):
pass
for resource in resources:
url = os.path.join(self.heat_url, 'stacks', id,
'myStack/60f83b5e/resources', resource['resource_name'])
if raise_exception:
self.requests_mock.register_uri('PATCH', url,
exc=MyException("Any stuff"))
else:
self.requests_mock.register_uri('PATCH', url)
def test_create_wait(self):
self._response_in_wait_until_stack_ready(["CREATE_IN_PROGRESS",
"CREATE_COMPLETE"])
@ -235,10 +269,16 @@ class TestOpenStack(base.FixturedTestCase):
region_name=None)
self.assertEqual(dummy_event['id'], event_id)
def _response_in_resource_get_list(self):
def _response_in_resource_get_list(self, stack_id=None,
resources=None):
# response for heat_client's resource_get_list()
url = self.heat_url + '/stacks/' + self.stack_id + '/resources'
json = {'resources': [fd_utils.get_dummy_resource()]}
if stack_id:
url = self.heat_url + '/stacks/' + stack_id + '/resources'
else:
url = self.heat_url + '/stacks/' + self.stack_id + '/resources'
resources = resources or [fd_utils.get_dummy_resource()]
json = {'resources': resources}
self.requests_mock.register_uri('GET', url, json=json,
headers=self.json_headers)
@ -763,3 +803,269 @@ class TestOpenStack(base.FixturedTestCase):
vnf_instance.instantiated_vnf_info.
ext_managed_virtual_link_info[0].vnf_link_ports[0].
resource_handle.resource_id)
def test_heal_vnf_instance(self):
v_s_resource_info = fd_utils.get_virtual_storage_resource_info(
desc_id="storage1")
storage_resource_ids = [v_s_resource_info.id]
vnfc_resource_info = fd_utils.get_vnfc_resource_info(vdu_id="VDU_VNF",
storage_resource_ids=storage_resource_ids)
inst_vnf_info = fd_utils.get_vnf_instantiated_info(
virtual_storage_resource_info=[v_s_resource_info],
vnfc_resource_info=[vnfc_resource_info])
vnf_instance = fd_utils.get_vnf_instance_object(
instantiated_vnf_info=inst_vnf_info)
vim_connection_info = fd_utils.get_vim_connection_info_object()
heal_vnf_request = objects.HealVnfRequest(
vnfc_instance_id=[vnfc_resource_info.id],
cause="healing request")
# Mock various heat APIs that will be called by heatclient
# during the process of heal_vnf.
resources = [{
'resource_name': vnfc_resource_info.vdu_id,
'resource_type': vnfc_resource_info.compute_resource.
vim_level_resource_type,
'physical_resource_id': vnfc_resource_info.compute_resource.
resource_id}, {
'resource_name': v_s_resource_info.virtual_storage_desc_id,
'resource_type': v_s_resource_info.storage_resource.
vim_level_resource_type,
'physical_resource_id': v_s_resource_info.storage_resource.
resource_id}]
self._response_in_stack_get(inst_vnf_info.instance_id)
self._response_in_resource_get_list(inst_vnf_info.instance_id,
resources=resources)
self._responses_in_stack_list(inst_vnf_info.instance_id,
resources=resources)
self._response_in_stack_update(inst_vnf_info.instance_id)
self._response_resource_mark_unhealthy(inst_vnf_info.instance_id,
resources=resources)
self.openstack.heal_vnf(
self.context, vnf_instance, vim_connection_info, heal_vnf_request)
history = self.requests_mock.request_history
patch_req = [req.url for req in history if req.method == 'PATCH']
# Total 3 times patch should be called, 2 for marking resources
# as unhealthy, and 1 for updating stack
self.assertEqual(3, len(patch_req))
def test_heal_vnf_instance_resource_mark_unhealthy_error(self):
vnfc_resource_info = fd_utils.get_vnfc_resource_info(vdu_id="VDU_VNF")
inst_vnf_info = fd_utils.get_vnf_instantiated_info(
vnfc_resource_info=[vnfc_resource_info])
vnf_instance = fd_utils.get_vnf_instance_object(
instantiated_vnf_info=inst_vnf_info)
vim_connection_info = fd_utils.get_vim_connection_info_object()
heal_vnf_request = objects.HealVnfRequest(
vnfc_instance_id=[vnfc_resource_info.id],
cause="healing request")
# Mock various heat APIs that will be called by heatclient
# during the process of heal_vnf.
resources = [{
'resource_name': vnfc_resource_info.vdu_id,
'resource_type': vnfc_resource_info.compute_resource.
vim_level_resource_type,
'physical_resource_id': vnfc_resource_info.compute_resource.
resource_id}]
self._response_in_stack_get(inst_vnf_info.instance_id)
self._response_in_resource_get_list(inst_vnf_info.instance_id,
resources=resources)
self._responses_in_stack_list(inst_vnf_info.instance_id,
resources=resources)
self._response_resource_mark_unhealthy(inst_vnf_info.instance_id,
resources=resources, raise_exception=True)
result = self.assertRaises(exceptions.VnfHealFailed,
self.openstack.heal_vnf, self.context, vnf_instance,
vim_connection_info, heal_vnf_request)
expected_msg = ("Failed to mark stack '%(id)s' resource as unhealthy "
"for resource '%(resource_name)s'") % {
'id': inst_vnf_info.instance_id,
'resource_name': resources[0]['resource_name']}
self.assertIn(expected_msg, str(result))