--- /dev/null
+#!/usr/bin/env python3
+
+#
+# Copyright 2016 RIFT.IO Inc
+#
+# 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 argparse
+import asyncio
+import logging
+import os
+import sys
+import time
+import unittest
+import uuid
+
+import xmlrunner
+
+import gi.repository.RwDts as rwdts
+import gi.repository.RwNsmYang as rwnsmyang
+import gi.repository.RwResourceMgrYang as RwResourceMgrYang
+import gi.repository.RwLaunchpadYang as launchpadyang
+import rift.tasklets
+import rift.test.dts
+
+import mano_ut
+
+
+if sys.version_info < (3, 4, 4):
+ asyncio.ensure_future = asyncio.async
+
+
+class OutOfResourceError(Exception):
+ pass
+
+
+class ComputeResourceRequestMockEventHandler(object):
+ def __init__(self):
+ self._pool_name = "vm_pool"
+ self._vdu_id = str(uuid.uuid4())
+ self._vdu_info = {
+ "vdu_id": self._vdu_id,
+ "state": "active",
+ "management_ip": "1.1.1.1",
+ "public_ip": "1.1.1.1",
+ "connection_points": [],
+ }
+
+ self._resource_state = "active"
+
+ self._event_id = None
+ self._request_info = None
+
+ def allocate(self, event_id, request_info):
+ self._event_id = event_id
+ self._request_info = request_info
+
+ self._vdu_info.update({
+ "name": self._request_info.name,
+ "flavor_id": self._request_info.flavor_id,
+ "image_id": self._request_info.image_id,
+ })
+
+ for cp in request_info.connection_points:
+ info_cp = dict(
+ name=cp.name,
+ virtual_link_id=cp.virtual_link_id,
+ vdu_id=self._vdu_id,
+ state="active",
+ ip_address="1.2.3.4",
+ )
+ info_cp = self._vdu_info["connection_points"].append(info_cp)
+
+ @property
+ def event_id(self):
+ return self._event_id
+
+ @property
+ def resource_state(self):
+ return self._resource_state
+
+ def set_active(self):
+ self._resource_state = "active"
+
+ def set_failed(self):
+ self._resource_state = "failed"
+
+ def set_pending(self):
+ self._resource_state = "pending"
+
+ @property
+ def response_msg(self):
+ resource_info = dict(
+ pool_name=self._pool_name,
+ resource_state=self.resource_state,
+ )
+ resource_info.update(self._vdu_info)
+
+ response = RwResourceMgrYang.VDUEventData.from_dict(dict(
+ event_id=self._event_id,
+ request_info=self._request_info.as_dict(),
+ resource_info=resource_info,
+ ))
+
+ return response.resource_info
+
+
+class NetworkResourceRequestMockEventHandler(object):
+ def __init__(self):
+ self._pool_name = "network_pool"
+ self._link_id = str(uuid.uuid4())
+ self._link_info = {
+ "virtual_link_id": self._link_id,
+ "state": "active",
+ }
+
+ self._resource_state = "active"
+
+ self._event_id = None
+ self._request_info = None
+
+ def allocate(self, event_id, request_info):
+ self._event_id = event_id
+ self._request_info = request_info
+
+ self._link_info.update({
+ "name": self._request_info.name,
+ "subnet": self._request_info.subnet,
+ })
+
+ @property
+ def event_id(self):
+ return self._event_id
+
+ @property
+ def resource_state(self):
+ return self._resource_state
+
+ def set_active(self):
+ self._resource_state = "active"
+
+ def set_failed(self):
+ self._resource_state = "failed"
+
+ def set_pending(self):
+ self._resource_state = "pending"
+
+ @property
+ def response_msg(self):
+ resource_info = dict(
+ pool_name=self._pool_name,
+ resource_state=self.resource_state,
+ )
+ resource_info.update(self._link_info)
+
+ response = RwResourceMgrYang.VirtualLinkEventData.from_dict(dict(
+ event_id=self._event_id,
+ request_info=self._request_info.as_dict(),
+ resource_info=resource_info,
+ ))
+
+ return response.resource_info
+
+
+class ResourceMgrMock(object):
+ VDU_REQUEST_XPATH = "D,/rw-resource-mgr:resource-mgmt/vdu-event/vdu-event-data"
+ VLINK_REQUEST_XPATH = "D,/rw-resource-mgr:resource-mgmt/vlink-event/vlink-event-data"
+
+ def __init__(self, dts, log, loop):
+ self._log = log
+ self._dts = dts
+ self._loop = loop
+ self._vdu_reg = None
+ self._link_reg = None
+
+ self._vdu_reg_event = asyncio.Event(loop=self._loop)
+ self._link_reg_event = asyncio.Event(loop=self._loop)
+
+ self._available_compute_handlers = []
+ self._available_network_handlers = []
+
+ self._used_compute_handlers = {}
+ self._used_network_handlers = {}
+
+ self._compute_allocate_requests = 0
+ self._network_allocate_requests = 0
+
+ self._registered = False
+
+ def _allocate_virtual_compute(self, event_id, request_info):
+ self._compute_allocate_requests += 1
+
+ if not self._available_compute_handlers:
+ raise OutOfResourceError("No more compute handlers")
+
+ handler = self._available_compute_handlers.pop()
+ handler.allocate(event_id, request_info)
+ self._used_compute_handlers[event_id] = handler
+
+ return handler.response_msg
+
+ def _allocate_virtual_network(self, event_id, request_info):
+ self._network_allocate_requests += 1
+
+ if not self._available_network_handlers:
+ raise OutOfResourceError("No more network handlers")
+
+ handler = self._available_network_handlers.pop()
+ handler.allocate(event_id, request_info)
+ self._used_network_handlers[event_id] = handler
+
+ return handler.response_msg
+
+ def _release_virtual_network(self, event_id):
+ del self._used_network_handlers[event_id]
+
+ def _release_virtual_compute(self, event_id):
+ del self._used_compute_handlers[event_id]
+
+ def _read_virtual_network(self, event_id):
+ return self._used_network_handlers[event_id].response_msg
+
+ def _read_virtual_compute(self, event_id):
+ return self._used_compute_handlers[event_id].response_msg
+
+ @asyncio.coroutine
+ def on_link_request_prepare(self, xact_info, action, ks_path, request_msg):
+ if not self._registered:
+ self._log.error("Got a prepare callback when not registered!")
+ xact_info.respond_xpath(rwdts.XactRspCode.NA)
+ return
+
+ self._log.debug("Received virtual-link on_prepare callback (self: %s, xact_info: %s, action: %s): %s",
+ self, xact_info, action, request_msg)
+
+ response_info = None
+ response_xpath = ks_path.to_xpath(RwResourceMgrYang.get_schema()) + "/resource-info"
+
+ schema = RwResourceMgrYang.VirtualLinkEventData().schema()
+ pathentry = schema.keyspec_to_entry(ks_path)
+
+ if action == rwdts.QueryAction.CREATE:
+ response_info = self._allocate_virtual_network(
+ pathentry.key00.event_id,
+ request_msg.request_info,
+ )
+
+ elif action == rwdts.QueryAction.DELETE:
+ self._release_virtual_network(pathentry.key00.event_id)
+
+ elif action == rwdts.QueryAction.READ:
+ response_info = self._read_virtual_network(
+ pathentry.key00.event_id
+ )
+ else:
+ raise ValueError("Only read/create/delete actions available. Received action: %s" %(action))
+
+ self._log.debug("Responding with VirtualLinkInfo at xpath %s: %s.",
+ response_xpath, response_info)
+
+ xact_info.respond_xpath(rwdts.XactRspCode.ACK, response_xpath, response_info)
+
+ @asyncio.coroutine
+ def on_vdu_request_prepare(self, xact_info, action, ks_path, request_msg):
+ if not self._registered:
+ self._log.error("Got a prepare callback when not registered!")
+ xact_info.respond_xpath(rwdts.XactRspCode.NA)
+ return
+
+ @asyncio.coroutine
+ def monitor_vdu_state(response_xpath, pathentry):
+ self._log.info("Initiating VDU state monitoring for xpath: %s ", response_xpath)
+ loop_cnt = 120
+ while loop_cnt > 0:
+ self._log.debug("VDU state monitoring: Sleeping for 1 second ")
+ yield from asyncio.sleep(1, loop = self._loop)
+ try:
+ response_info = self._read_virtual_compute(
+ pathentry.key00.event_id
+ )
+ except Exception as e:
+ self._log.error(
+ "VDU state monitoring: Received exception %s "
+ "in VDU state monitoring for %s. Aborting monitoring",
+ str(e), response_xpath
+ )
+ raise
+
+ if response_info.resource_state == 'active' or response_info.resource_state == 'failed':
+ self._log.info(
+ "VDU state monitoring: VDU reached terminal state."
+ "Publishing VDU info: %s at path: %s",
+ response_info, response_xpath
+ )
+ yield from self._dts.query_update(response_xpath,
+ rwdts.XactFlag.ADVISE,
+ response_info)
+ return
+ else:
+ loop_cnt -= 1
+
+ ### End of while loop. This is only possible if VDU did not reach active state
+ self._log.info("VDU state monitoring: VDU at xpath :%s did not reached active state in 120 seconds. Aborting monitoring",
+ response_xpath)
+ response_info = RwResourceMgrYang.VDUEventData_ResourceInfo()
+ response_info.resource_state = 'failed'
+ yield from self._dts.query_update(response_xpath,
+ rwdts.XactFlag.ADVISE,
+ response_info)
+ return
+
+ self._log.debug("Received vdu on_prepare callback (xact_info: %s, action: %s): %s",
+ xact_info, action, request_msg)
+
+ response_info = None
+ response_xpath = ks_path.to_xpath(RwResourceMgrYang.get_schema()) + "/resource-info"
+
+ schema = RwResourceMgrYang.VDUEventData().schema()
+ pathentry = schema.keyspec_to_entry(ks_path)
+
+ if action == rwdts.QueryAction.CREATE:
+ response_info = self._allocate_virtual_compute(
+ pathentry.key00.event_id,
+ request_msg.request_info,
+ )
+ if response_info.resource_state == 'pending':
+ asyncio.ensure_future(monitor_vdu_state(response_xpath, pathentry),
+ loop = self._loop)
+
+ elif action == rwdts.QueryAction.DELETE:
+ self._release_virtual_compute(
+ pathentry.key00.event_id
+ )
+
+ elif action == rwdts.QueryAction.READ:
+ response_info = self._read_virtual_compute(
+ pathentry.key00.event_id
+ )
+ else:
+ raise ValueError("Only create/delete actions available. Received action: %s" %(action))
+
+ self._log.debug("Responding with VDUInfo at xpath %s: %s",
+ response_xpath, response_info)
+
+ xact_info.respond_xpath(rwdts.XactRspCode.ACK, response_xpath, response_info)
+
+ @asyncio.coroutine
+ def register(self):
+ @asyncio.coroutine
+ def on_request_ready(registration, status):
+ self._log.debug("Got request ready event (registration: %s) (status: %s)",
+ registration, status)
+
+ if registration == self._link_reg:
+ self._link_reg_event.set()
+ elif registration == self._vdu_reg:
+ self._vdu_reg_event.set()
+ else:
+ self._log.error("Unknown registration ready event: %s", registration)
+
+
+ with self._dts.group_create() as group:
+ self._log.debug("Registering for Link Resource Request using xpath: %s",
+ ResourceMgrMock.VLINK_REQUEST_XPATH)
+
+ self._link_reg = group.register(
+ xpath=ResourceMgrMock.VLINK_REQUEST_XPATH,
+ handler=rift.tasklets.DTS.RegistrationHandler(on_ready=on_request_ready,
+ on_prepare=self.on_link_request_prepare),
+ flags=rwdts.Flag.PUBLISHER)
+
+ self._log.debug("Registering for VDU Resource Request using xpath: %s",
+ ResourceMgrMock.VDU_REQUEST_XPATH)
+
+ self._vdu_reg = group.register(
+ xpath=ResourceMgrMock.VDU_REQUEST_XPATH,
+ handler=rift.tasklets.DTS.RegistrationHandler(on_ready=on_request_ready,
+ on_prepare=self.on_vdu_request_prepare),
+ flags=rwdts.Flag.PUBLISHER)
+
+ self._registered = True
+
+ def unregister(self):
+ self._link_reg.deregister()
+ self._vdu_reg.deregister()
+ self._registered = False
+
+ @asyncio.coroutine
+ def wait_ready(self, timeout=5):
+ self._log.debug("Waiting for all request registrations to become ready.")
+ yield from asyncio.wait([self._link_reg_event.wait(), self._vdu_reg_event.wait()],
+ timeout=timeout, loop=self._loop)
+
+ def create_compute_mock_event_handler(self):
+ handler = ComputeResourceRequestMockEventHandler()
+ self._available_compute_handlers.append(handler)
+
+ return handler
+
+ def create_network_mock_event_handler(self):
+ handler = NetworkResourceRequestMockEventHandler()
+ self._available_network_handlers.append(handler)
+
+ return handler
+
+ @property
+ def num_compute_requests(self):
+ return self._compute_allocate_requests
+
+ @property
+ def num_network_requests(self):
+ return self._network_allocate_requests
+
+ @property
+ def num_allocated_compute_resources(self):
+ return len(self._used_compute_handlers)
+
+ @property
+ def num_allocated_network_resources(self):
+ return len(self._used_network_handlers)
+
+
+@unittest.skip('failing and needs rework')
+class ManoErrorTestCase(rift.test.dts.AbstractDTSTest):
+ """
+ DTS GI interface unittests
+
+ Note: Each tests uses a list of asyncio.Events for staging through the
+ test. These are required here because we are bring up each coroutine
+ ("tasklet") at the same time and are not implementing any re-try
+ mechanisms. For instance, this is used in numerous tests to make sure that
+ a publisher is up and ready before the subscriber sends queries. Such
+ event lists should not be used in production software.
+ """
+
+ @classmethod
+ def configure_suite(cls, rwmain):
+ plugin_dir = os.path.join(os.environ["RIFT_INSTALL"], "usr/lib/rift/plugins")
+ rwmain.add_tasklet(
+ os.path.join(plugin_dir, 'rwvns'),
+ 'rwvnstasklet'
+ )
+
+ rwmain.add_tasklet(
+ os.path.join(plugin_dir, 'rwvnfm'),
+ 'rwvnfmtasklet'
+ )
+
+ rwmain.add_tasklet(
+ os.path.join(plugin_dir, 'rwnsm'),
+ 'rwnsmtasklet'
+ )
+
+ cls.waited_for_tasklets = False
+
+ @asyncio.coroutine
+ def register_mock_res_mgr(self):
+ self.res_mgr = ResourceMgrMock(
+ self.dts,
+ self.log,
+ self.loop,
+ )
+ yield from self.res_mgr.register()
+
+ self.log.info("Waiting for resource manager to be ready")
+ yield from self.res_mgr.wait_ready()
+
+ def unregister_mock_res_mgr(self):
+ self.res_mgr.unregister()
+
+ @classmethod
+ def configure_schema(cls):
+ return rwnsmyang.get_schema()
+
+ @classmethod
+ def configure_timeout(cls):
+ return 240
+
+ @asyncio.coroutine
+ def wait_tasklets(self):
+ if not ManoErrorTestCase.waited_for_tasklets:
+ yield from asyncio.sleep(5, loop=self.loop)
+ ManoErrorTestCase.waited_for_tasklets = True
+
+ @asyncio.coroutine
+ def publish_desciptors(self, num_external_vlrs=1, num_internal_vlrs=1, num_ping_vms=1):
+ yield from self.ping_pong.publish_desciptors(
+ num_external_vlrs,
+ num_internal_vlrs,
+ num_ping_vms
+ )
+
+ def unpublish_descriptors(self):
+ self.ping_pong.unpublish_descriptors()
+
+ @asyncio.coroutine
+ def wait_until_nsr_active_or_failed(self, nsr_id, timeout_secs=20):
+ start_time = time.time()
+ while (time.time() - start_time) < timeout_secs:
+ nsrs = yield from self.querier.get_nsr_opdatas(nsr_id)
+ self.assertEqual(1, len(nsrs))
+ if nsrs[0].operational_status in ['running', 'failed']:
+ return
+
+ self.log.debug("Rcvd NSR with %s status", nsrs[0].operational_status)
+ yield from asyncio.sleep(2, loop=self.loop)
+
+ self.assertIn(nsrs[0].operational_status, ['running', 'failed'])
+
+ def verify_number_compute_requests(self, num_requests):
+ self.assertEqual(num_requests, self.res_mgr.num_compute_requests)
+
+ def verify_number_network_requests(self, num_requests):
+ self.assertEqual(num_requests, self.res_mgr.num_network_requests)
+
+ def verify_number_allocated_compute(self, num_allocated):
+ self.assertEqual(num_allocated, self.res_mgr.num_allocated_compute_resources)
+
+ def verify_number_allocated_network(self, num_allocated):
+ self.assertEqual(num_allocated, self.res_mgr.num_allocated_network_resources)
+
+ def allocate_network_handlers(self, num_networks):
+ return [self.res_mgr.create_network_mock_event_handler() for _ in range(num_networks)]
+
+ def allocate_compute_handlers(self, num_computes):
+ return [self.res_mgr.create_compute_mock_event_handler() for _ in range(num_computes)]
+
+ @asyncio.coroutine
+ def create_mock_launchpad_tasklet(self):
+ yield from mano_ut.create_mock_launchpad_tasklet(self.log, self.dts)
+
+ def configure_test(self, loop, test_id):
+ self.log.debug("STARTING - %s", self.id())
+ self.tinfo = self.new_tinfo(self.id())
+ self.dts = rift.tasklets.DTS(self.tinfo, self.schema, self.loop)
+ self.ping_pong = mano_ut.PingPongDescriptorPublisher(self.log, self.loop, self.dts)
+ self.querier = mano_ut.ManoQuerier(self.log, self.dts)
+
+ # Add a task to wait for tasklets to come up
+ asyncio.ensure_future(self.wait_tasklets(), loop=self.loop)
+
+ @rift.test.dts.async_test
+ def test_fail_first_nsm_vlr(self):
+ yield from self.publish_desciptors(num_external_vlrs=2)
+ yield from self.register_mock_res_mgr()
+
+ nsr_id = yield from self.ping_pong.create_nsr()
+ yield from self.wait_until_nsr_active_or_failed(nsr_id)
+
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 1)
+ yield from self.verify_nsr_state(nsr_id, "failed")
+ yield from self.verify_num_vlrs(1)
+ yield from self.verify_num_nsr_vlrs(nsr_id, 2)
+ yield from self.verify_num_vnfrs(0)
+
+ nsr_vlrs = yield from self.get_nsr_vlrs(nsr_id)
+ yield from self.verify_vlr_state(nsr_vlrs[0], "failed")
+
+ self.verify_number_network_requests(1)
+ self.verify_number_compute_requests(0)
+ self.verify_number_allocated_network(0)
+ self.verify_number_allocated_compute(0)
+
+ yield from self.terminate_nsr(nsr_id)
+
+ yield from self.verify_nsr_deleted(nsr_id)
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 0)
+ yield from self.verify_num_vlrs(0)
+
+ self.verify_number_allocated_network(0)
+ self.verify_number_allocated_compute(0)
+
+ self.unregister_mock_res_mgr()
+ self.unpublish_descriptors()
+
+ @rift.test.dts.async_test
+ def test_fail_second_nsm_vlr(self):
+ yield from self.publish_desciptors(num_external_vlrs=2)
+ yield from self.register_mock_res_mgr()
+ self.allocate_network_handlers(1)
+
+ nsr_id = yield from self.ping_pong.create_nsr()
+ yield from self.wait_until_nsr_active_or_failed(nsr_id)
+
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 1)
+ yield from self.verify_nsr_state(nsr_id, "failed")
+ yield from self.verify_num_vlrs(2)
+ yield from self.verify_num_nsr_vlrs(nsr_id, 2)
+
+ nsr_vlrs = yield from self.get_nsr_vlrs(nsr_id)
+ yield from self.verify_vlr_state(nsr_vlrs[0], "running")
+ yield from self.verify_vlr_state(nsr_vlrs[1], "failed")
+
+ self.verify_number_network_requests(2)
+ self.verify_number_compute_requests(0)
+ self.verify_number_allocated_network(1)
+ self.verify_number_allocated_compute(0)
+
+ yield from self.terminate_nsr(nsr_id)
+
+ yield from self.verify_nsr_deleted(nsr_id)
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 0)
+ yield from self.verify_num_vlrs(0)
+
+ self.verify_number_allocated_network(0)
+ self.verify_number_allocated_compute(0)
+
+ self.unregister_mock_res_mgr()
+ self.unpublish_descriptors()
+
+ @rift.test.dts.async_test
+ def test_fail_first_vnf_first_vlr(self):
+ yield from self.publish_desciptors(num_internal_vlrs=2)
+ yield from self.register_mock_res_mgr()
+ self.allocate_network_handlers(1)
+
+ nsr_id = yield from self.ping_pong.create_nsr()
+ yield from self.wait_until_nsr_active_or_failed(nsr_id)
+
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 1)
+ yield from self.verify_nsr_state(nsr_id, "failed")
+ yield from self.verify_num_vlrs(2)
+ yield from self.verify_num_nsr_vlrs(nsr_id, 1)
+
+ nsr_vlrs = yield from self.get_nsr_vlrs(nsr_id)
+ yield from self.verify_vlr_state(nsr_vlrs[0], "running")
+
+ yield from self.verify_num_nsr_vnfrs(nsr_id, 2)
+
+ # Verify only a single vnfr was instantiated and is failed
+ yield from self.verify_num_vnfrs(1)
+ nsr_vnfs = yield from self.get_nsr_vnfs(nsr_id)
+ yield from self.verify_vnf_state(nsr_vnfs[0], "failed")
+
+ yield from self.verify_num_vnfr_vlrs(nsr_vnfs[0], 2)
+ vnf_vlrs = yield from self.get_vnf_vlrs(nsr_vnfs[0])
+ yield from self.verify_vlr_state(vnf_vlrs[0], "failed")
+
+ self.verify_number_network_requests(2)
+ self.verify_number_compute_requests(0)
+ self.verify_number_allocated_network(1)
+ self.verify_number_allocated_compute(0)
+
+ yield from self.terminate_nsr(nsr_id)
+
+ yield from self.verify_nsr_deleted(nsr_id)
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 0)
+ yield from self.verify_num_vlrs(0)
+
+ self.verify_number_allocated_network(0)
+ self.verify_number_allocated_compute(0)
+
+ self.unregister_mock_res_mgr()
+ self.unpublish_descriptors()
+
+ @rift.test.dts.async_test
+ def test_fail_first_vnf_second_vlr(self):
+ yield from self.publish_desciptors(num_internal_vlrs=2)
+ yield from self.register_mock_res_mgr()
+ self.allocate_network_handlers(2)
+
+ nsr_id = yield from self.ping_pong.create_nsr()
+ yield from self.wait_until_nsr_active_or_failed(nsr_id)
+
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 1)
+ yield from self.verify_nsr_state(nsr_id, "failed")
+ yield from self.verify_num_vlrs(3)
+ yield from self.verify_num_nsr_vlrs(nsr_id, 1)
+
+ nsr_vlrs = yield from self.get_nsr_vlrs(nsr_id)
+ yield from self.verify_vlr_state(nsr_vlrs[0], "running")
+
+ yield from self.verify_num_nsr_vnfrs(nsr_id, 2)
+
+ # Verify only a single vnfr was instantiated and is failed
+ yield from self.verify_num_vnfrs(1)
+ nsr_vnfs = yield from self.get_nsr_vnfs(nsr_id)
+ yield from self.verify_vnf_state(nsr_vnfs[0], "failed")
+
+ yield from self.verify_num_vnfr_vlrs(nsr_vnfs[0], 2)
+ vnf_vlrs = yield from self.get_vnf_vlrs(nsr_vnfs[0])
+ yield from self.verify_vlr_state(vnf_vlrs[0], "running")
+ yield from self.verify_vlr_state(vnf_vlrs[1], "failed")
+
+ self.verify_number_network_requests(3)
+ self.verify_number_compute_requests(0)
+ self.verify_number_allocated_network(2)
+ self.verify_number_allocated_compute(0)
+
+ yield from self.terminate_nsr(nsr_id)
+
+ yield from self.verify_nsr_deleted(nsr_id)
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 0)
+ yield from self.verify_num_vlrs(0)
+
+ self.verify_number_allocated_network(0)
+ self.verify_number_allocated_compute(0)
+
+ self.unregister_mock_res_mgr()
+ self.unpublish_descriptors()
+
+ @rift.test.dts.async_test
+ def test_fail_first_vnf_first_vdu(self):
+ yield from self.publish_desciptors(num_internal_vlrs=2, num_ping_vms=2)
+ yield from self.register_mock_res_mgr()
+ yield from self.create_mock_launchpad_tasklet()
+ self.allocate_network_handlers(3)
+
+ nsr_id = yield from self.ping_pong.create_nsr()
+ yield from self.wait_until_nsr_active_or_failed(nsr_id)
+
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 1)
+ yield from self.verify_nsr_state(nsr_id, "failed")
+ yield from self.verify_num_vlrs(3)
+ yield from self.verify_num_nsr_vlrs(nsr_id, 1)
+
+ nsr_vlrs = yield from self.get_nsr_vlrs(nsr_id)
+ yield from self.verify_vlr_state(nsr_vlrs[0], "running")
+
+ yield from self.verify_num_nsr_vnfrs(nsr_id, 2)
+
+ # Verify only a single vnfr was instantiated and is failed
+ yield from self.verify_num_vnfrs(1)
+ nsr_vnfs = yield from self.get_nsr_vnfs(nsr_id)
+ yield from self.verify_vnf_state(nsr_vnfs[0], "failed")
+
+ yield from self.verify_num_vnfr_vlrs(nsr_vnfs[0], 2)
+ vnf_vlrs = yield from self.get_vnf_vlrs(nsr_vnfs[0])
+ yield from self.verify_vlr_state(vnf_vlrs[0], "running")
+ yield from self.verify_vlr_state(vnf_vlrs[1], "running")
+
+ yield from self.verify_num_vnfr_vdus(nsr_vnfs[0], 2)
+ vdus = yield from self.get_vnf_vdus(nsr_vnfs[0])
+ self.verify_vdu_state(vdus[0], "failed")
+
+ self.verify_number_network_requests(3)
+ self.verify_number_compute_requests(1)
+ self.verify_number_allocated_network(3)
+ self.verify_number_allocated_compute(0)
+
+ yield from self.terminate_nsr(nsr_id)
+
+ yield from self.verify_nsr_deleted(nsr_id)
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 0)
+ yield from self.verify_num_vlrs(0)
+
+ self.verify_number_allocated_network(0)
+ self.verify_number_allocated_compute(0)
+
+ self.unregister_mock_res_mgr()
+ self.unpublish_descriptors()
+
+ @rift.test.dts.async_test
+ def test_fail_first_vnf_second_vdu(self):
+ yield from self.publish_desciptors(num_internal_vlrs=2, num_ping_vms=2)
+ yield from self.register_mock_res_mgr()
+ yield from self.create_mock_launchpad_tasklet()
+ self.allocate_network_handlers(3)
+ self.allocate_compute_handlers(1)
+
+ nsr_id = yield from self.ping_pong.create_nsr()
+ yield from self.wait_until_nsr_active_or_failed(nsr_id)
+
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 1)
+ yield from self.verify_nsr_state(nsr_id, "failed")
+ yield from self.verify_num_vlrs(3)
+ yield from self.verify_num_nsr_vlrs(nsr_id, 1)
+
+ nsr_vlrs = yield from self.get_nsr_vlrs(nsr_id)
+ yield from self.verify_vlr_state(nsr_vlrs[0], "running")
+
+ yield from self.verify_num_nsr_vnfrs(nsr_id, 2)
+
+ # Verify only a single vnfr was instantiated and is failed
+ yield from self.verify_num_vnfrs(1)
+ nsr_vnfs = yield from self.get_nsr_vnfs(nsr_id)
+ yield from self.verify_vnf_state(nsr_vnfs[0], "failed")
+
+ yield from self.verify_num_vnfr_vlrs(nsr_vnfs[0], 2)
+ vnf_vlrs = yield from self.get_vnf_vlrs(nsr_vnfs[0])
+ yield from self.verify_vlr_state(vnf_vlrs[0], "running")
+ yield from self.verify_vlr_state(vnf_vlrs[1], "running")
+
+ yield from self.verify_num_vnfr_vdus(nsr_vnfs[0], 2)
+
+ vdus = yield from self.get_vnf_vdus(nsr_vnfs[0])
+ self.verify_vdu_state(vdus[0], "running")
+ self.verify_vdu_state(vdus[1], "failed")
+
+ self.verify_number_network_requests(3)
+ self.verify_number_compute_requests(2)
+ self.verify_number_allocated_network(3)
+ self.verify_number_allocated_compute(1)
+
+ yield from self.terminate_nsr(nsr_id)
+
+ yield from self.verify_nsr_deleted(nsr_id)
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 0)
+ yield from self.verify_num_vlrs(0)
+
+ self.verify_number_allocated_network(0)
+ self.verify_number_allocated_compute(0)
+
+ self.unregister_mock_res_mgr()
+ self.unpublish_descriptors()
+
+ @rift.test.dts.async_test
+ def test_fail_second_vnf_second_vdu(self):
+ yield from self.publish_desciptors(num_internal_vlrs=2, num_ping_vms=2)
+ yield from self.register_mock_res_mgr()
+ yield from self.create_mock_launchpad_tasklet()
+ self.allocate_network_handlers(5)
+ self.allocate_compute_handlers(3)
+
+ nsr_id = yield from self.ping_pong.create_nsr()
+ yield from self.wait_until_nsr_active_or_failed(nsr_id)
+
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 1)
+ yield from self.verify_nsr_state(nsr_id, "failed")
+ yield from self.verify_num_vlrs(5)
+ yield from self.verify_num_nsr_vlrs(nsr_id, 1)
+
+ nsr_vlrs = yield from self.get_nsr_vlrs(nsr_id)
+ yield from self.verify_vlr_state(nsr_vlrs[0], "running")
+
+ yield from self.verify_num_nsr_vnfrs(nsr_id, 2)
+
+ # Verify only a single vnfr was instantiated and is failed
+ yield from self.verify_num_vnfrs(2)
+ nsr_vnfs = yield from self.get_nsr_vnfs(nsr_id)
+ yield from self.verify_vnf_state(nsr_vnfs[0], "running")
+ yield from self.verify_vnf_state(nsr_vnfs[1], "failed")
+
+ yield from self.verify_num_vnfr_vlrs(nsr_vnfs[0], 2)
+
+ vnf_vlrs = yield from self.get_vnf_vlrs(nsr_vnfs[0])
+ yield from self.verify_vlr_state(vnf_vlrs[0], "running")
+ yield from self.verify_vlr_state(vnf_vlrs[1], "running")
+
+ vnf_vlrs = yield from self.get_vnf_vlrs(nsr_vnfs[1])
+ yield from self.verify_vlr_state(vnf_vlrs[0], "running")
+ yield from self.verify_vlr_state(vnf_vlrs[1], "running")
+
+ yield from self.verify_num_vnfr_vdus(nsr_vnfs[0], 2)
+ yield from self.verify_num_vnfr_vdus(nsr_vnfs[1], 2)
+
+ vdus = yield from self.get_vnf_vdus(nsr_vnfs[0])
+ self.verify_vdu_state(vdus[0], "running")
+ self.verify_vdu_state(vdus[1], "running")
+
+ vdus = yield from self.get_vnf_vdus(nsr_vnfs[1])
+ self.verify_vdu_state(vdus[0], "running")
+ self.verify_vdu_state(vdus[1], "failed")
+
+ self.verify_number_network_requests(5)
+ self.verify_number_compute_requests(4)
+ self.verify_number_allocated_network(5)
+ self.verify_number_allocated_compute(3)
+
+ yield from self.terminate_nsr(nsr_id)
+
+ yield from self.verify_nsr_deleted(nsr_id)
+ yield from self.verify_nsd_ref_count(self.ping_pong.nsd_id, 0)
+ yield from self.verify_num_vlrs(0)
+
+ self.verify_number_allocated_network(0)
+ self.verify_number_allocated_compute(0)
+
+ self.unregister_mock_res_mgr()
+ self.unpublish_descriptors()
+
+
+def main():
+ runner = xmlrunner.XMLTestRunner(output=os.environ["RIFT_MODULE_TEST"])
+
+ parser = argparse.ArgumentParser()
+ parser.add_argument('-v', '--verbose', action='store_true')
+ args, _ = parser.parse_known_args()
+
+ ManoErrorTestCase.log_level = logging.DEBUG if args.verbose else logging.WARN
+
+ unittest.main(testRunner=runner)
+
+if __name__ == '__main__':
+ main()
+
+# vim: sw
projects / osm / SO.git / blobdiff