4 # Copyright 2016 RIFT.IO Inc
6 # Licensed under the Apache License, Version 2.0 (the "License");
7 # you may not use this file except in compliance with the License.
8 # You may obtain a copy of the License at
10 # http://www.apache.org/licenses/LICENSE-2.0
12 # Unless required by applicable law or agreed to in writing, software
13 # distributed under the License is distributed on an "AS IS" BASIS,
14 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 # See the License for the specific language governing permissions and
16 # limitations under the License.
30 import gi
.repository
.RwDts
as rwdts
31 import gi
.repository
.RwNsmYang
as rwnsmyang
32 import gi
.repository
.RwResourceMgrYang
as RwResourceMgrYang
33 import gi
.repository
.RwLaunchpadYang
as launchpadyang
40 if sys
.version_info
< (3, 4, 4):
41 asyncio
.ensure_future
= asyncio
.async
44 class OutOfResourceError(Exception):
48 class ComputeResourceRequestMockEventHandler(object):
50 self
._pool
_name
= "vm_pool"
51 self
._vdu
_id
= str(uuid
.uuid4())
53 "vdu_id": self
._vdu
_id
,
55 "management_ip": "1.1.1.1",
56 "public_ip": "1.1.1.1",
57 "connection_points": [],
60 self
._resource
_state
= "active"
63 self
._request
_info
= None
65 def allocate(self
, event_id
, request_info
):
66 self
._event
_id
= event_id
67 self
._request
_info
= request_info
69 self
._vdu
_info
.update({
70 "name": self
._request
_info
.name
,
71 "flavor_id": self
._request
_info
.flavor_id
,
72 "image_id": self
._request
_info
.image_id
,
75 for cp
in request_info
.connection_points
:
78 virtual_link_id
=cp
.virtual_link_id
,
83 info_cp
= self
._vdu
_info
["connection_points"].append(info_cp
)
90 def resource_state(self
):
91 return self
._resource
_state
94 self
._resource
_state
= "active"
97 self
._resource
_state
= "failed"
99 def set_pending(self
):
100 self
._resource
_state
= "pending"
103 def response_msg(self
):
104 resource_info
= dict(
105 pool_name
=self
._pool
_name
,
106 resource_state
=self
.resource_state
,
108 resource_info
.update(self
._vdu
_info
)
110 response
= RwResourceMgrYang
.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData
.from_dict(dict(
111 event_id
=self
._event
_id
,
112 request_info
=self
._request
_info
.as_dict(),
113 resource_info
=resource_info
,
116 return response
.resource_info
119 class NetworkResourceRequestMockEventHandler(object):
121 self
._pool
_name
= "network_pool"
122 self
._link
_id
= str(uuid
.uuid4())
124 "virtual_link_id": self
._link
_id
,
128 self
._resource
_state
= "active"
130 self
._event
_id
= None
131 self
._request
_info
= None
133 def allocate(self
, event_id
, request_info
):
134 self
._event
_id
= event_id
135 self
._request
_info
= request_info
137 self
._link
_info
.update({
138 "name": self
._request
_info
.name
,
139 "subnet": self
._request
_info
.subnet
,
144 return self
._event
_id
147 def resource_state(self
):
148 return self
._resource
_state
150 def set_active(self
):
151 self
._resource
_state
= "active"
153 def set_failed(self
):
154 self
._resource
_state
= "failed"
156 def set_pending(self
):
157 self
._resource
_state
= "pending"
160 def response_msg(self
):
161 resource_info
= dict(
162 pool_name
=self
._pool
_name
,
163 resource_state
=self
.resource_state
,
165 resource_info
.update(self
._link
_info
)
167 response
= RwResourceMgrYang
.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData
.from_dict(dict(
168 event_id
=self
._event
_id
,
169 request_info
=self
._request
_info
.as_dict(),
170 resource_info
=resource_info
,
173 return response
.resource_info
176 class ResourceMgrMock(object):
177 VDU_REQUEST_XPATH
= "D,/rw-project:project/rw-resource-mgr:resource-mgmt/vdu-event/vdu-event-data"
178 VLINK_REQUEST_XPATH
= "D,/rw-project:project/rw-resource-mgr:resource-mgmt/vlink-event/vlink-event-data"
180 def __init__(self
, dts
, log
, loop
):
185 self
._link
_reg
= None
187 self
._vdu
_reg
_event
= asyncio
.Event(loop
=self
._loop
)
188 self
._link
_reg
_event
= asyncio
.Event(loop
=self
._loop
)
190 self
._available
_compute
_handlers
= []
191 self
._available
_network
_handlers
= []
193 self
._used
_compute
_handlers
= {}
194 self
._used
_network
_handlers
= {}
196 self
._compute
_allocate
_requests
= 0
197 self
._network
_allocate
_requests
= 0
199 self
._registered
= False
201 def _allocate_virtual_compute(self
, event_id
, request_info
):
202 self
._compute
_allocate
_requests
+= 1
204 if not self
._available
_compute
_handlers
:
205 raise OutOfResourceError("No more compute handlers")
207 handler
= self
._available
_compute
_handlers
.pop()
208 handler
.allocate(event_id
, request_info
)
209 self
._used
_compute
_handlers
[event_id
] = handler
211 return handler
.response_msg
213 def _allocate_virtual_network(self
, event_id
, request_info
):
214 self
._network
_allocate
_requests
+= 1
216 if not self
._available
_network
_handlers
:
217 raise OutOfResourceError("No more network handlers")
219 handler
= self
._available
_network
_handlers
.pop()
220 handler
.allocate(event_id
, request_info
)
221 self
._used
_network
_handlers
[event_id
] = handler
223 return handler
.response_msg
225 def _release_virtual_network(self
, event_id
):
226 del self
._used
_network
_handlers
[event_id
]
228 def _release_virtual_compute(self
, event_id
):
229 del self
._used
_compute
_handlers
[event_id
]
231 def _read_virtual_network(self
, event_id
):
232 return self
._used
_network
_handlers
[event_id
].response_msg
234 def _read_virtual_compute(self
, event_id
):
235 return self
._used
_compute
_handlers
[event_id
].response_msg
238 def on_link_request_prepare(self
, xact_info
, action
, ks_path
, request_msg
):
239 if not self
._registered
:
240 self
._log
.error("Got a prepare callback when not registered!")
241 xact_info
.respond_xpath(rwdts
.XactRspCode
.NA
)
244 self
._log
.debug("Received virtual-link on_prepare callback (self: %s, xact_info: %s, action: %s): %s",
245 self
, xact_info
, action
, request_msg
)
248 response_xpath
= ks_path
.to_xpath(RwResourceMgrYang
.get_schema()) + "/resource-info"
250 schema
= RwResourceMgrYang
.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData().schema()
251 pathentry
= schema
.keyspec_to_entry(ks_path
)
253 if action
== rwdts
.QueryAction
.CREATE
:
254 response_info
= self
._allocate
_virtual
_network
(
255 pathentry
.key00
.event_id
,
256 request_msg
.request_info
,
259 elif action
== rwdts
.QueryAction
.DELETE
:
260 self
._release
_virtual
_network
(pathentry
.key00
.event_id
)
262 elif action
== rwdts
.QueryAction
.READ
:
263 response_info
= self
._read
_virtual
_network
(
264 pathentry
.key00
.event_id
267 raise ValueError("Only read/create/delete actions available. Received action: %s" %(action))
269 self
._log
.debug("Responding with VirtualLinkInfo at xpath %s: %s.",
270 response_xpath
, response_info
)
272 xact_info
.respond_xpath(rwdts
.XactRspCode
.ACK
, response_xpath
, response_info
)
275 def on_vdu_request_prepare(self
, xact_info
, action
, ks_path
, request_msg
):
276 if not self
._registered
:
277 self
._log
.error("Got a prepare callback when not registered!")
278 xact_info
.respond_xpath(rwdts
.XactRspCode
.NA
)
282 def monitor_vdu_state(response_xpath
, event_id
):
283 self
._log
.info("Initiating VDU state monitoring for xpath: %s ", response_xpath
)
286 self
._log
.debug("VDU state monitoring: Sleeping for 1 second ")
287 yield from asyncio
.sleep(1, loop
= self
._loop
)
289 response_info
= self
._read
_virtual
_compute
(event_id
)
290 except Exception as e
:
292 "VDU state monitoring: Received exception %s "
293 "in VDU state monitoring for %s. Aborting monitoring",
294 str(e
), response_xpath
298 if response_info
.resource_state
== 'active' or response_info
.resource_state
== 'failed':
300 "VDU state monitoring: VDU reached terminal state."
301 "Publishing VDU info: %s at path: %s",
302 response_info
, response_xpath
304 yield from self
._dts
.query_update(response_xpath
,
305 rwdts
.XactFlag
.ADVISE
,
311 ### End of while loop. This is only possible if VDU did not reach active state
312 self
._log
.info("VDU state monitoring: VDU at xpath :%s did not reached active state in 120 seconds. Aborting monitoring",
314 response_info
= RwResourceMgrYang
.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData_ResourceInfo()
315 response_info
.resource_state
= 'failed'
316 yield from self
._dts
.query_update(response_xpath
,
317 rwdts
.XactFlag
.ADVISE
,
321 self
._log
.debug("Received vdu on_prepare callback (xact_info: %s, action: %s): %s",
322 xact_info
, action
, request_msg
)
325 response_xpath
= ks_path
.to_xpath(RwResourceMgrYang
.get_schema()) + "/resource-info"
327 schema
= RwResourceMgrYang
.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData().schema()
328 pathentry
= schema
.keyspec_to_entry(ks_path
)
330 if action
== rwdts
.QueryAction
.CREATE
:
331 response_info
= self
._allocate
_virtual
_compute
(
332 pathentry
.key00
.event_id
,
333 request_msg
.request_info
,
335 if response_info
.resource_state
== 'pending':
336 asyncio
.ensure_future(monitor_vdu_state(response_xpath
, pathentry
.key00
.event_id
),
339 elif action
== rwdts
.QueryAction
.DELETE
:
340 self
._release
_virtual
_compute
(
341 pathentry
.key00
.event_id
344 elif action
== rwdts
.QueryAction
.READ
:
345 response_info
= self
._read
_virtual
_compute
(
346 pathentry
.key00
.event_id
349 raise ValueError("Only create/delete actions available. Received action: %s" %(action))
351 self
._log
.debug("Responding with VDUInfo at xpath %s: %s",
352 response_xpath
, response_info
)
354 xact_info
.respond_xpath(rwdts
.XactRspCode
.ACK
, response_xpath
, response_info
)
359 def on_request_ready(registration
, status
):
360 self
._log
.debug("Got request ready event (registration: %s) (status: %s)",
361 registration
, status
)
363 if registration
== self
._link
_reg
:
364 self
._link
_reg
_event
.set()
365 elif registration
== self
._vdu
_reg
:
366 self
._vdu
_reg
_event
.set()
368 self
._log
.error("Unknown registration ready event: %s", registration
)
371 with self
._dts
.group_create() as group
:
372 self
._log
.debug("Registering for Link Resource Request using xpath: %s",
373 ResourceMgrMock
.VLINK_REQUEST_XPATH
)
375 self
._link
_reg
= group
.register(
376 xpath
=ResourceMgrMock
.VLINK_REQUEST_XPATH
,
377 handler
=rift
.tasklets
.DTS
.RegistrationHandler(on_ready
=on_request_ready
,
378 on_prepare
=self
.on_link_request_prepare
),
379 flags
=rwdts
.Flag
.PUBLISHER
)
381 self
._log
.debug("Registering for VDU Resource Request using xpath: %s",
382 ResourceMgrMock
.VDU_REQUEST_XPATH
)
384 self
._vdu
_reg
= group
.register(
385 xpath
=ResourceMgrMock
.VDU_REQUEST_XPATH
,
386 handler
=rift
.tasklets
.DTS
.RegistrationHandler(on_ready
=on_request_ready
,
387 on_prepare
=self
.on_vdu_request_prepare
),
388 flags
=rwdts
.Flag
.PUBLISHER
)
390 self
._registered
= True
392 def unregister(self
):
393 self
._link
_reg
.deregister()
394 self
._vdu
_reg
.deregister()
395 self
._registered
= False
398 def wait_ready(self
, timeout
=5):
399 self
._log
.debug("Waiting for all request registrations to become ready.")
400 yield from asyncio
.wait([self
._link
_reg
_event
.wait(), self
._vdu
_reg
_event
.wait()],
401 timeout
=timeout
, loop
=self
._loop
)
403 def create_compute_mock_event_handler(self
):
404 handler
= ComputeResourceRequestMockEventHandler()
405 self
._available
_compute
_handlers
.append(handler
)
409 def create_network_mock_event_handler(self
):
410 handler
= NetworkResourceRequestMockEventHandler()
411 self
._available
_network
_handlers
.append(handler
)
416 def num_compute_requests(self
):
417 return self
._compute
_allocate
_requests
420 def num_network_requests(self
):
421 return self
._network
_allocate
_requests
424 def num_allocated_compute_resources(self
):
425 return len(self
._used
_compute
_handlers
)
428 def num_allocated_network_resources(self
):
429 return len(self
._used
_network
_handlers
)
432 @unittest.skip('failing and needs rework')
433 class ManoErrorTestCase(rift
.test
.dts
.AbstractDTSTest
):
435 DTS GI interface unittests
437 Note: Each tests uses a list of asyncio.Events for staging through the
438 test. These are required here because we are bring up each coroutine
439 ("tasklet") at the same time and are not implementing any re-try
440 mechanisms. For instance, this is used in numerous tests to make sure that
441 a publisher is up and ready before the subscriber sends queries. Such
442 event lists should not be used in production software.
446 def configure_suite(cls
, rwmain
):
447 plugin_dir
= os
.path
.join(os
.environ
["RIFT_INSTALL"], "usr/lib/rift/plugins")
449 os
.path
.join(plugin_dir
, 'rwvns'),
454 os
.path
.join(plugin_dir
, 'rwvnfm'),
459 os
.path
.join(plugin_dir
, 'rwnsm'),
463 cls
.waited_for_tasklets
= False
466 def register_mock_res_mgr(self
):
467 self
.res_mgr
= ResourceMgrMock(
472 yield from self
.res_mgr
.register()
474 self
.log
.info("Waiting for resource manager to be ready")
475 yield from self
.res_mgr
.wait_ready()
477 def unregister_mock_res_mgr(self
):
478 self
.res_mgr
.unregister()
481 def configure_schema(cls
):
482 return rwnsmyang
.get_schema()
485 def configure_timeout(cls
):
489 def wait_tasklets(self
):
490 if not ManoErrorTestCase
.waited_for_tasklets
:
491 yield from asyncio
.sleep(5, loop
=self
.loop
)
492 ManoErrorTestCase
.waited_for_tasklets
= True
495 def publish_desciptors(self
, num_external_vlrs
=1, num_internal_vlrs
=1, num_ping_vms
=1):
496 yield from self
.ping_pong
.publish_desciptors(
502 def unpublish_descriptors(self
):
503 self
.ping_pong
.unpublish_descriptors()
506 def wait_until_nsr_active_or_failed(self
, nsr_id
, timeout_secs
=20):
507 start_time
= time
.time()
508 while (time
.time() - start_time
) < timeout_secs
:
509 nsrs
= yield from self
.querier
.get_nsr_opdatas(nsr_id
)
510 self
.assertEqual(1, len(nsrs
))
511 if nsrs
[0].operational_status
in ['running', 'failed']:
514 self
.log
.debug("Rcvd NSR with %s status", nsrs
[0].operational_status
)
515 yield from asyncio
.sleep(2, loop
=self
.loop
)
517 self
.assertIn(nsrs
[0].operational_status
, ['running', 'failed'])
519 def verify_number_compute_requests(self
, num_requests
):
520 self
.assertEqual(num_requests
, self
.res_mgr
.num_compute_requests
)
522 def verify_number_network_requests(self
, num_requests
):
523 self
.assertEqual(num_requests
, self
.res_mgr
.num_network_requests
)
525 def verify_number_allocated_compute(self
, num_allocated
):
526 self
.assertEqual(num_allocated
, self
.res_mgr
.num_allocated_compute_resources
)
528 def verify_number_allocated_network(self
, num_allocated
):
529 self
.assertEqual(num_allocated
, self
.res_mgr
.num_allocated_network_resources
)
531 def allocate_network_handlers(self
, num_networks
):
532 return [self
.res_mgr
.create_network_mock_event_handler() for _
in range(num_networks
)]
534 def allocate_compute_handlers(self
, num_computes
):
535 return [self
.res_mgr
.create_compute_mock_event_handler() for _
in range(num_computes
)]
538 def create_mock_launchpad_tasklet(self
):
539 yield from mano_ut
.create_mock_launchpad_tasklet(self
.log
, self
.dts
)
541 def configure_test(self
, loop
, test_id
):
542 self
.log
.debug("STARTING - %s", self
.id())
543 self
.tinfo
= self
.new_tinfo(self
.id())
544 self
.dts
= rift
.tasklets
.DTS(self
.tinfo
, self
.schema
, self
.loop
)
545 self
.ping_pong
= mano_ut
.PingPongDescriptorPublisher(self
.log
, self
.loop
, self
.dts
)
546 self
.querier
= mano_ut
.ManoQuerier(self
.log
, self
.dts
)
548 # Add a task to wait for tasklets to come up
549 asyncio
.ensure_future(self
.wait_tasklets(), loop
=self
.loop
)
551 @rift.test
.dts
.async_test
552 def test_fail_first_nsm_vlr(self
):
553 yield from self
.publish_desciptors(num_external_vlrs
=2)
554 yield from self
.register_mock_res_mgr()
556 nsr_id
= yield from self
.ping_pong
.create_nsr()
557 yield from self
.wait_until_nsr_active_or_failed(nsr_id
)
559 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 1)
560 yield from self
.verify_nsr_state(nsr_id
, "failed")
561 yield from self
.verify_num_vlrs(1)
562 yield from self
.verify_num_nsr_vlrs(nsr_id
, 2)
563 yield from self
.verify_num_vnfrs(0)
565 nsr_vlrs
= yield from self
.get_nsr_vlrs(nsr_id
)
566 yield from self
.verify_vlr_state(nsr_vlrs
[0], "failed")
568 self
.verify_number_network_requests(1)
569 self
.verify_number_compute_requests(0)
570 self
.verify_number_allocated_network(0)
571 self
.verify_number_allocated_compute(0)
573 yield from self
.terminate_nsr(nsr_id
)
575 yield from self
.verify_nsr_deleted(nsr_id
)
576 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 0)
577 yield from self
.verify_num_vlrs(0)
579 self
.verify_number_allocated_network(0)
580 self
.verify_number_allocated_compute(0)
582 self
.unregister_mock_res_mgr()
583 self
.unpublish_descriptors()
585 @rift.test
.dts
.async_test
586 def test_fail_second_nsm_vlr(self
):
587 yield from self
.publish_desciptors(num_external_vlrs
=2)
588 yield from self
.register_mock_res_mgr()
589 self
.allocate_network_handlers(1)
591 nsr_id
= yield from self
.ping_pong
.create_nsr()
592 yield from self
.wait_until_nsr_active_or_failed(nsr_id
)
594 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 1)
595 yield from self
.verify_nsr_state(nsr_id
, "failed")
596 yield from self
.verify_num_vlrs(2)
597 yield from self
.verify_num_nsr_vlrs(nsr_id
, 2)
599 nsr_vlrs
= yield from self
.get_nsr_vlrs(nsr_id
)
600 yield from self
.verify_vlr_state(nsr_vlrs
[0], "running")
601 yield from self
.verify_vlr_state(nsr_vlrs
[1], "failed")
603 self
.verify_number_network_requests(2)
604 self
.verify_number_compute_requests(0)
605 self
.verify_number_allocated_network(1)
606 self
.verify_number_allocated_compute(0)
608 yield from self
.terminate_nsr(nsr_id
)
610 yield from self
.verify_nsr_deleted(nsr_id
)
611 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 0)
612 yield from self
.verify_num_vlrs(0)
614 self
.verify_number_allocated_network(0)
615 self
.verify_number_allocated_compute(0)
617 self
.unregister_mock_res_mgr()
618 self
.unpublish_descriptors()
620 @rift.test
.dts
.async_test
621 def test_fail_first_vnf_first_vlr(self
):
622 yield from self
.publish_desciptors(num_internal_vlrs
=2)
623 yield from self
.register_mock_res_mgr()
624 self
.allocate_network_handlers(1)
626 nsr_id
= yield from self
.ping_pong
.create_nsr()
627 yield from self
.wait_until_nsr_active_or_failed(nsr_id
)
629 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 1)
630 yield from self
.verify_nsr_state(nsr_id
, "failed")
631 yield from self
.verify_num_vlrs(2)
632 yield from self
.verify_num_nsr_vlrs(nsr_id
, 1)
634 nsr_vlrs
= yield from self
.get_nsr_vlrs(nsr_id
)
635 yield from self
.verify_vlr_state(nsr_vlrs
[0], "running")
637 yield from self
.verify_num_nsr_vnfrs(nsr_id
, 2)
639 # Verify only a single vnfr was instantiated and is failed
640 yield from self
.verify_num_vnfrs(1)
641 nsr_vnfs
= yield from self
.get_nsr_vnfs(nsr_id
)
642 yield from self
.verify_vnf_state(nsr_vnfs
[0], "failed")
644 yield from self
.verify_num_vnfr_vlrs(nsr_vnfs
[0], 2)
645 vnf_vlrs
= yield from self
.get_vnf_vlrs(nsr_vnfs
[0])
646 yield from self
.verify_vlr_state(vnf_vlrs
[0], "failed")
648 self
.verify_number_network_requests(2)
649 self
.verify_number_compute_requests(0)
650 self
.verify_number_allocated_network(1)
651 self
.verify_number_allocated_compute(0)
653 yield from self
.terminate_nsr(nsr_id
)
655 yield from self
.verify_nsr_deleted(nsr_id
)
656 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 0)
657 yield from self
.verify_num_vlrs(0)
659 self
.verify_number_allocated_network(0)
660 self
.verify_number_allocated_compute(0)
662 self
.unregister_mock_res_mgr()
663 self
.unpublish_descriptors()
665 @rift.test
.dts
.async_test
666 def test_fail_first_vnf_second_vlr(self
):
667 yield from self
.publish_desciptors(num_internal_vlrs
=2)
668 yield from self
.register_mock_res_mgr()
669 self
.allocate_network_handlers(2)
671 nsr_id
= yield from self
.ping_pong
.create_nsr()
672 yield from self
.wait_until_nsr_active_or_failed(nsr_id
)
674 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 1)
675 yield from self
.verify_nsr_state(nsr_id
, "failed")
676 yield from self
.verify_num_vlrs(3)
677 yield from self
.verify_num_nsr_vlrs(nsr_id
, 1)
679 nsr_vlrs
= yield from self
.get_nsr_vlrs(nsr_id
)
680 yield from self
.verify_vlr_state(nsr_vlrs
[0], "running")
682 yield from self
.verify_num_nsr_vnfrs(nsr_id
, 2)
684 # Verify only a single vnfr was instantiated and is failed
685 yield from self
.verify_num_vnfrs(1)
686 nsr_vnfs
= yield from self
.get_nsr_vnfs(nsr_id
)
687 yield from self
.verify_vnf_state(nsr_vnfs
[0], "failed")
689 yield from self
.verify_num_vnfr_vlrs(nsr_vnfs
[0], 2)
690 vnf_vlrs
= yield from self
.get_vnf_vlrs(nsr_vnfs
[0])
691 yield from self
.verify_vlr_state(vnf_vlrs
[0], "running")
692 yield from self
.verify_vlr_state(vnf_vlrs
[1], "failed")
694 self
.verify_number_network_requests(3)
695 self
.verify_number_compute_requests(0)
696 self
.verify_number_allocated_network(2)
697 self
.verify_number_allocated_compute(0)
699 yield from self
.terminate_nsr(nsr_id
)
701 yield from self
.verify_nsr_deleted(nsr_id
)
702 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 0)
703 yield from self
.verify_num_vlrs(0)
705 self
.verify_number_allocated_network(0)
706 self
.verify_number_allocated_compute(0)
708 self
.unregister_mock_res_mgr()
709 self
.unpublish_descriptors()
711 @rift.test
.dts
.async_test
712 def test_fail_first_vnf_first_vdu(self
):
713 yield from self
.publish_desciptors(num_internal_vlrs
=2, num_ping_vms
=2)
714 yield from self
.register_mock_res_mgr()
715 yield from self
.create_mock_launchpad_tasklet()
716 self
.allocate_network_handlers(3)
718 nsr_id
= yield from self
.ping_pong
.create_nsr()
719 yield from self
.wait_until_nsr_active_or_failed(nsr_id
)
721 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 1)
722 yield from self
.verify_nsr_state(nsr_id
, "failed")
723 yield from self
.verify_num_vlrs(3)
724 yield from self
.verify_num_nsr_vlrs(nsr_id
, 1)
726 nsr_vlrs
= yield from self
.get_nsr_vlrs(nsr_id
)
727 yield from self
.verify_vlr_state(nsr_vlrs
[0], "running")
729 yield from self
.verify_num_nsr_vnfrs(nsr_id
, 2)
731 # Verify only a single vnfr was instantiated and is failed
732 yield from self
.verify_num_vnfrs(1)
733 nsr_vnfs
= yield from self
.get_nsr_vnfs(nsr_id
)
734 yield from self
.verify_vnf_state(nsr_vnfs
[0], "failed")
736 yield from self
.verify_num_vnfr_vlrs(nsr_vnfs
[0], 2)
737 vnf_vlrs
= yield from self
.get_vnf_vlrs(nsr_vnfs
[0])
738 yield from self
.verify_vlr_state(vnf_vlrs
[0], "running")
739 yield from self
.verify_vlr_state(vnf_vlrs
[1], "running")
741 yield from self
.verify_num_vnfr_vdus(nsr_vnfs
[0], 2)
742 vdus
= yield from self
.get_vnf_vdus(nsr_vnfs
[0])
743 self
.verify_vdu_state(vdus
[0], "failed")
745 self
.verify_number_network_requests(3)
746 self
.verify_number_compute_requests(1)
747 self
.verify_number_allocated_network(3)
748 self
.verify_number_allocated_compute(0)
750 yield from self
.terminate_nsr(nsr_id
)
752 yield from self
.verify_nsr_deleted(nsr_id
)
753 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 0)
754 yield from self
.verify_num_vlrs(0)
756 self
.verify_number_allocated_network(0)
757 self
.verify_number_allocated_compute(0)
759 self
.unregister_mock_res_mgr()
760 self
.unpublish_descriptors()
762 @rift.test
.dts
.async_test
763 def test_fail_first_vnf_second_vdu(self
):
764 yield from self
.publish_desciptors(num_internal_vlrs
=2, num_ping_vms
=2)
765 yield from self
.register_mock_res_mgr()
766 yield from self
.create_mock_launchpad_tasklet()
767 self
.allocate_network_handlers(3)
768 self
.allocate_compute_handlers(1)
770 nsr_id
= yield from self
.ping_pong
.create_nsr()
771 yield from self
.wait_until_nsr_active_or_failed(nsr_id
)
773 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 1)
774 yield from self
.verify_nsr_state(nsr_id
, "failed")
775 yield from self
.verify_num_vlrs(3)
776 yield from self
.verify_num_nsr_vlrs(nsr_id
, 1)
778 nsr_vlrs
= yield from self
.get_nsr_vlrs(nsr_id
)
779 yield from self
.verify_vlr_state(nsr_vlrs
[0], "running")
781 yield from self
.verify_num_nsr_vnfrs(nsr_id
, 2)
783 # Verify only a single vnfr was instantiated and is failed
784 yield from self
.verify_num_vnfrs(1)
785 nsr_vnfs
= yield from self
.get_nsr_vnfs(nsr_id
)
786 yield from self
.verify_vnf_state(nsr_vnfs
[0], "failed")
788 yield from self
.verify_num_vnfr_vlrs(nsr_vnfs
[0], 2)
789 vnf_vlrs
= yield from self
.get_vnf_vlrs(nsr_vnfs
[0])
790 yield from self
.verify_vlr_state(vnf_vlrs
[0], "running")
791 yield from self
.verify_vlr_state(vnf_vlrs
[1], "running")
793 yield from self
.verify_num_vnfr_vdus(nsr_vnfs
[0], 2)
795 vdus
= yield from self
.get_vnf_vdus(nsr_vnfs
[0])
796 self
.verify_vdu_state(vdus
[0], "running")
797 self
.verify_vdu_state(vdus
[1], "failed")
799 self
.verify_number_network_requests(3)
800 self
.verify_number_compute_requests(2)
801 self
.verify_number_allocated_network(3)
802 self
.verify_number_allocated_compute(1)
804 yield from self
.terminate_nsr(nsr_id
)
806 yield from self
.verify_nsr_deleted(nsr_id
)
807 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 0)
808 yield from self
.verify_num_vlrs(0)
810 self
.verify_number_allocated_network(0)
811 self
.verify_number_allocated_compute(0)
813 self
.unregister_mock_res_mgr()
814 self
.unpublish_descriptors()
816 @rift.test
.dts
.async_test
817 def test_fail_second_vnf_second_vdu(self
):
818 yield from self
.publish_desciptors(num_internal_vlrs
=2, num_ping_vms
=2)
819 yield from self
.register_mock_res_mgr()
820 yield from self
.create_mock_launchpad_tasklet()
821 self
.allocate_network_handlers(5)
822 self
.allocate_compute_handlers(3)
824 nsr_id
= yield from self
.ping_pong
.create_nsr()
825 yield from self
.wait_until_nsr_active_or_failed(nsr_id
)
827 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 1)
828 yield from self
.verify_nsr_state(nsr_id
, "failed")
829 yield from self
.verify_num_vlrs(5)
830 yield from self
.verify_num_nsr_vlrs(nsr_id
, 1)
832 nsr_vlrs
= yield from self
.get_nsr_vlrs(nsr_id
)
833 yield from self
.verify_vlr_state(nsr_vlrs
[0], "running")
835 yield from self
.verify_num_nsr_vnfrs(nsr_id
, 2)
837 # Verify only a single vnfr was instantiated and is failed
838 yield from self
.verify_num_vnfrs(2)
839 nsr_vnfs
= yield from self
.get_nsr_vnfs(nsr_id
)
840 yield from self
.verify_vnf_state(nsr_vnfs
[0], "running")
841 yield from self
.verify_vnf_state(nsr_vnfs
[1], "failed")
843 yield from self
.verify_num_vnfr_vlrs(nsr_vnfs
[0], 2)
845 vnf_vlrs
= yield from self
.get_vnf_vlrs(nsr_vnfs
[0])
846 yield from self
.verify_vlr_state(vnf_vlrs
[0], "running")
847 yield from self
.verify_vlr_state(vnf_vlrs
[1], "running")
849 vnf_vlrs
= yield from self
.get_vnf_vlrs(nsr_vnfs
[1])
850 yield from self
.verify_vlr_state(vnf_vlrs
[0], "running")
851 yield from self
.verify_vlr_state(vnf_vlrs
[1], "running")
853 yield from self
.verify_num_vnfr_vdus(nsr_vnfs
[0], 2)
854 yield from self
.verify_num_vnfr_vdus(nsr_vnfs
[1], 2)
856 vdus
= yield from self
.get_vnf_vdus(nsr_vnfs
[0])
857 self
.verify_vdu_state(vdus
[0], "running")
858 self
.verify_vdu_state(vdus
[1], "running")
860 vdus
= yield from self
.get_vnf_vdus(nsr_vnfs
[1])
861 self
.verify_vdu_state(vdus
[0], "running")
862 self
.verify_vdu_state(vdus
[1], "failed")
864 self
.verify_number_network_requests(5)
865 self
.verify_number_compute_requests(4)
866 self
.verify_number_allocated_network(5)
867 self
.verify_number_allocated_compute(3)
869 yield from self
.terminate_nsr(nsr_id
)
871 yield from self
.verify_nsr_deleted(nsr_id
)
872 yield from self
.verify_nsd_ref_count(self
.ping_pong
.nsd_id
, 0)
873 yield from self
.verify_num_vlrs(0)
875 self
.verify_number_allocated_network(0)
876 self
.verify_number_allocated_compute(0)
878 self
.unregister_mock_res_mgr()
879 self
.unpublish_descriptors()
883 runner
= xmlrunner
.XMLTestRunner(output
=os
.environ
["RIFT_MODULE_TEST"])
885 parser
= argparse
.ArgumentParser()
886 parser
.add_argument('-v', '--verbose', action
='store_true')
887 args
, _
= parser
.parse_known_args()
889 ManoErrorTestCase
.log_level
= logging
.DEBUG
if args
.verbose
else logging
.WARN
891 unittest
.main(testRunner
=runner
)
893 if __name__
== '__main__':