rwlaunchpad/test/mano_error_ut.py

   1 #!/usr/bin/env python3
   2
   3 #
   4 #   Copyright 2016 RIFT.IO Inc
   5 #
   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
   9 #
  10 #       http://www.apache.org/licenses/LICENSE-2.0
  11 #
  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.
  17 #
  18
  19 import argparse
  20 import asyncio
  21 import logging
  22 import os
  23 import sys
  24 import time
  25 import unittest
  26 import uuid
  27
  28 import xmlrunner
  29
  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
  34 import rift.tasklets
  35 import rift.test.dts
  36
  37 import mano_ut
  38
  39
  40 if sys.version_info < (3, 4, 4):
  41     asyncio.ensure_future = asyncio.async
  42
  43
  44 class OutOfResourceError(Exception):
  45     pass
  46
  47
  48 class ComputeResourceRequestMockEventHandler(object):
  49     def __init__(self):
  50         self._pool_name = "vm_pool"
  51         self._vdu_id = str(uuid.uuid4())
  52         self._vdu_info = {
  53                 "vdu_id": self._vdu_id,
  54                 "state": "active",
  55                 "management_ip": "1.1.1.1",
  56                 "public_ip": "1.1.1.1",
  57                 "connection_points": [],
  58                 }
  59
  60         self._resource_state = "active"
  61
  62         self._event_id = None
  63         self._request_info = None
  64
  65     def allocate(self, event_id, request_info):
  66         self._event_id = event_id
  67         self._request_info = request_info
  68
  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,
  73             })
  74
  75         for cp in request_info.connection_points:
  76             info_cp = dict(
  77                 name=cp.name,
  78                 virtual_link_id=cp.virtual_link_id,
  79                 vdu_id=self._vdu_id,
  80                 state="active",
  81                 ip_address="1.2.3.4",
  82                 )
  83             info_cp = self._vdu_info["connection_points"].append(info_cp)
  84
  85     @property
  86     def event_id(self):
  87         return self._event_id
  88
  89     @property
  90     def resource_state(self):
  91         return self._resource_state
  92
  93     def set_active(self):
  94         self._resource_state = "active"
  95
  96     def set_failed(self):
  97         self._resource_state = "failed"
  98
  99     def set_pending(self):
 100         self._resource_state = "pending"
 101
 102     @property
 103     def response_msg(self):
 104         resource_info = dict(
 105                 pool_name=self._pool_name,
 106                 resource_state=self.resource_state,
 107                 )
 108         resource_info.update(self._vdu_info)
 109
 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,
 114             ))
 115
 116         return response.resource_info
 117
 118
 119 class NetworkResourceRequestMockEventHandler(object):
 120     def __init__(self):
 121         self._pool_name = "network_pool"
 122         self._link_id = str(uuid.uuid4())
 123         self._link_info = {
 124                 "virtual_link_id": self._link_id,
 125                 "state": "active",
 126                 }
 127
 128         self._resource_state = "active"
 129
 130         self._event_id = None
 131         self._request_info = None
 132
 133     def allocate(self, event_id, request_info):
 134         self._event_id = event_id
 135         self._request_info = request_info
 136
 137         self._link_info.update({
 138             "name": self._request_info.name,
 139             "subnet": self._request_info.subnet,
 140             })
 141
 142     @property
 143     def event_id(self):
 144         return self._event_id
 145
 146     @property
 147     def resource_state(self):
 148         return self._resource_state
 149
 150     def set_active(self):
 151         self._resource_state = "active"
 152
 153     def set_failed(self):
 154         self._resource_state = "failed"
 155
 156     def set_pending(self):
 157         self._resource_state = "pending"
 158
 159     @property
 160     def response_msg(self):
 161         resource_info = dict(
 162                 pool_name=self._pool_name,
 163                 resource_state=self.resource_state,
 164                 )
 165         resource_info.update(self._link_info)
 166
 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,
 171             ))
 172
 173         return response.resource_info
 174
 175
 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"
 179
 180     def __init__(self, dts, log, loop):
 181         self._log = log
 182         self._dts = dts
 183         self._loop = loop
 184         self._vdu_reg = None
 185         self._link_reg = None
 186
 187         self._vdu_reg_event = asyncio.Event(loop=self._loop)
 188         self._link_reg_event = asyncio.Event(loop=self._loop)
 189
 190         self._available_compute_handlers = []
 191         self._available_network_handlers = []
 192
 193         self._used_compute_handlers = {}
 194         self._used_network_handlers = {}
 195
 196         self._compute_allocate_requests = 0
 197         self._network_allocate_requests = 0
 198
 199         self._registered = False
 200
 201     def _allocate_virtual_compute(self, event_id, request_info):
 202         self._compute_allocate_requests += 1
 203
 204         if not self._available_compute_handlers:
 205             raise OutOfResourceError("No more compute handlers")
 206
 207         handler = self._available_compute_handlers.pop()
 208         handler.allocate(event_id, request_info)
 209         self._used_compute_handlers[event_id] = handler
 210
 211         return handler.response_msg
 212
 213     def _allocate_virtual_network(self, event_id, request_info):
 214         self._network_allocate_requests += 1
 215
 216         if not self._available_network_handlers:
 217             raise OutOfResourceError("No more network handlers")
 218
 219         handler = self._available_network_handlers.pop()
 220         handler.allocate(event_id, request_info)
 221         self._used_network_handlers[event_id] = handler
 222
 223         return handler.response_msg
 224
 225     def _release_virtual_network(self, event_id):
 226         del self._used_network_handlers[event_id]
 227
 228     def _release_virtual_compute(self, event_id):
 229         del self._used_compute_handlers[event_id]
 230
 231     def _read_virtual_network(self, event_id):
 232         return self._used_network_handlers[event_id].response_msg
 233
 234     def _read_virtual_compute(self, event_id):
 235         return self._used_compute_handlers[event_id].response_msg
 236
 237     @asyncio.coroutine
 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)
 242             return
 243
 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)
 246
 247         response_info = None
 248         response_xpath = ks_path.to_xpath(RwResourceMgrYang.get_schema()) + "/resource-info"
 249
 250         schema = RwResourceMgrYang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData().schema()
 251         pathentry = schema.keyspec_to_entry(ks_path)
 252
 253         if action == rwdts.QueryAction.CREATE:
 254             response_info = self._allocate_virtual_network(
 255                     pathentry.key00.event_id,
 256                     request_msg.request_info,
 257                     )
 258
 259         elif action == rwdts.QueryAction.DELETE:
 260             self._release_virtual_network(pathentry.key00.event_id)
 261
 262         elif action == rwdts.QueryAction.READ:
 263             response_info = self._read_virtual_network(
 264                     pathentry.key00.event_id
 265                     )
 266         else:
 267             raise ValueError("Only read/create/delete actions available. Received action: %s" %(action))
 268
 269         self._log.debug("Responding with VirtualLinkInfo at xpath %s: %s.",
 270                         response_xpath, response_info)
 271
 272         xact_info.respond_xpath(rwdts.XactRspCode.ACK, response_xpath, response_info)
 273
 274     @asyncio.coroutine
 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)
 279             return
 280
 281         @asyncio.coroutine
 282         def monitor_vdu_state(response_xpath, event_id):
 283             self._log.info("Initiating VDU state monitoring for xpath: %s ", response_xpath)
 284             loop_cnt = 120
 285             while loop_cnt > 0:
 286                 self._log.debug("VDU state monitoring: Sleeping for 1 second ")
 287                 yield from asyncio.sleep(1, loop = self._loop)
 288                 try:
 289                     response_info = self._read_virtual_compute(event_id)
 290                 except Exception as e:
 291                     self._log.error(
 292                             "VDU state monitoring: Received exception %s "
 293                             "in VDU state monitoring for %s. Aborting monitoring",
 294                             str(e), response_xpath
 295                             )
 296                     raise
 297
 298                 if response_info.resource_state == 'active' or response_info.resource_state == 'failed':
 299                     self._log.info(
 300                             "VDU state monitoring: VDU reached terminal state."
 301                             "Publishing VDU info: %s at path: %s",
 302                             response_info, response_xpath
 303                             )
 304                     yield from self._dts.query_update(response_xpath,
 305                                                       rwdts.XactFlag.ADVISE,
 306                                                       response_info)
 307                     return
 308                 else:
 309                     loop_cnt -= 1
 310
 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",
 313                            response_xpath)
 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,
 318                                               response_info)
 319             return
 320
 321         self._log.debug("Received vdu on_prepare callback (xact_info: %s, action: %s): %s",
 322                         xact_info, action, request_msg)
 323
 324         response_info = None
 325         response_xpath = ks_path.to_xpath(RwResourceMgrYang.get_schema()) + "/resource-info"
 326
 327         schema = RwResourceMgrYang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData().schema()
 328         pathentry = schema.keyspec_to_entry(ks_path)
 329
 330         if action == rwdts.QueryAction.CREATE:
 331             response_info = self._allocate_virtual_compute(
 332                     pathentry.key00.event_id,
 333                     request_msg.request_info,
 334                     )
 335             if response_info.resource_state == 'pending':
 336                 asyncio.ensure_future(monitor_vdu_state(response_xpath, pathentry.key00.event_id),
 337                                       loop = self._loop)
 338
 339         elif action == rwdts.QueryAction.DELETE:
 340             self._release_virtual_compute(
 341                     pathentry.key00.event_id
 342                     )
 343
 344         elif action == rwdts.QueryAction.READ:
 345             response_info = self._read_virtual_compute(
 346                     pathentry.key00.event_id
 347                     )
 348         else:
 349             raise ValueError("Only create/delete actions available. Received action: %s" %(action))
 350
 351         self._log.debug("Responding with VDUInfo at xpath %s: %s",
 352                         response_xpath, response_info)
 353
 354         xact_info.respond_xpath(rwdts.XactRspCode.ACK, response_xpath, response_info)
 355
 356     @asyncio.coroutine
 357     def register(self):
 358         @asyncio.coroutine
 359         def on_request_ready(registration, status):
 360             self._log.debug("Got request ready event (registration: %s) (status: %s)",
 361                             registration, status)
 362
 363             if registration == self._link_reg:
 364                 self._link_reg_event.set()
 365             elif registration == self._vdu_reg:
 366                 self._vdu_reg_event.set()
 367             else:
 368                 self._log.error("Unknown registration ready event: %s", registration)
 369
 370
 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)
 374
 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)
 380
 381             self._log.debug("Registering for VDU Resource Request using xpath: %s",
 382                             ResourceMgrMock.VDU_REQUEST_XPATH)
 383
 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)
 389
 390         self._registered = True
 391
 392     def unregister(self):
 393         self._link_reg.deregister()
 394         self._vdu_reg.deregister()
 395         self._registered = False
 396
 397     @asyncio.coroutine
 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)
 402
 403     def create_compute_mock_event_handler(self):
 404         handler = ComputeResourceRequestMockEventHandler()
 405         self._available_compute_handlers.append(handler)
 406
 407         return handler
 408
 409     def create_network_mock_event_handler(self):
 410         handler = NetworkResourceRequestMockEventHandler()
 411         self._available_network_handlers.append(handler)
 412
 413         return handler
 414
 415     @property
 416     def num_compute_requests(self):
 417         return self._compute_allocate_requests
 418
 419     @property
 420     def num_network_requests(self):
 421         return self._network_allocate_requests
 422
 423     @property
 424     def num_allocated_compute_resources(self):
 425         return len(self._used_compute_handlers)
 426
 427     @property
 428     def num_allocated_network_resources(self):
 429         return len(self._used_network_handlers)
 430
 431
 432 @unittest.skip('failing and needs rework')
 433 class ManoErrorTestCase(rift.test.dts.AbstractDTSTest):
 434     """
 435     DTS GI interface unittests
 436
 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.
 443     """
 444
 445     @classmethod
 446     def configure_suite(cls, rwmain):
 447         plugin_dir = os.path.join(os.environ["RIFT_INSTALL"], "usr/lib/rift/plugins")
 448         rwmain.add_tasklet(
 449                 os.path.join(plugin_dir, 'rwvns'),
 450                 'rwvnstasklet'
 451                 )
 452
 453         rwmain.add_tasklet(
 454                 os.path.join(plugin_dir, 'rwvnfm'),
 455                 'rwvnfmtasklet'
 456                 )
 457
 458         rwmain.add_tasklet(
 459                 os.path.join(plugin_dir, 'rwnsm'),
 460                 'rwnsmtasklet'
 461                 )
 462
 463         cls.waited_for_tasklets = False
 464
 465     @asyncio.coroutine
 466     def register_mock_res_mgr(self):
 467         self.res_mgr = ResourceMgrMock(
 468                 self.dts,
 469                 self.log,
 470                 self.loop,
 471                 )
 472         yield from self.res_mgr.register()
 473
 474         self.log.info("Waiting for resource manager to be ready")
 475         yield from self.res_mgr.wait_ready()
 476
 477     def unregister_mock_res_mgr(self):
 478         self.res_mgr.unregister()
 479
 480     @classmethod
 481     def configure_schema(cls):
 482         return rwnsmyang.get_schema()
 483
 484     @classmethod
 485     def configure_timeout(cls):
 486         return 240
 487
 488     @asyncio.coroutine
 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
 493
 494     @asyncio.coroutine
 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(
 497                 num_external_vlrs,
 498                 num_internal_vlrs,
 499                 num_ping_vms
 500                 )
 501
 502     def unpublish_descriptors(self):
 503         self.ping_pong.unpublish_descriptors()
 504
 505     @asyncio.coroutine
 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']:
 512                 return
 513
 514             self.log.debug("Rcvd NSR with %s status", nsrs[0].operational_status)
 515             yield from asyncio.sleep(2, loop=self.loop)
 516
 517         self.assertIn(nsrs[0].operational_status, ['running', 'failed'])
 518
 519     def verify_number_compute_requests(self, num_requests):
 520         self.assertEqual(num_requests, self.res_mgr.num_compute_requests)
 521
 522     def verify_number_network_requests(self, num_requests):
 523         self.assertEqual(num_requests, self.res_mgr.num_network_requests)
 524
 525     def verify_number_allocated_compute(self, num_allocated):
 526         self.assertEqual(num_allocated, self.res_mgr.num_allocated_compute_resources)
 527
 528     def verify_number_allocated_network(self, num_allocated):
 529         self.assertEqual(num_allocated, self.res_mgr.num_allocated_network_resources)
 530
 531     def allocate_network_handlers(self, num_networks):
 532         return [self.res_mgr.create_network_mock_event_handler() for _ in range(num_networks)]
 533
 534     def allocate_compute_handlers(self, num_computes):
 535         return [self.res_mgr.create_compute_mock_event_handler() for _ in range(num_computes)]
 536
 537     @asyncio.coroutine
 538     def create_mock_launchpad_tasklet(self):
 539         yield from mano_ut.create_mock_launchpad_tasklet(self.log, self.dts)
 540
 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)
 547
 548         # Add a task to wait for tasklets to come up
 549         asyncio.ensure_future(self.wait_tasklets(), loop=self.loop)
 550
 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()
 555
 556         nsr_id = yield from self.ping_pong.create_nsr()
 557         yield from self.wait_until_nsr_active_or_failed(nsr_id)
 558
 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)
 564
 565         nsr_vlrs = yield from self.get_nsr_vlrs(nsr_id)
 566         yield from self.verify_vlr_state(nsr_vlrs[0], "failed")
 567
 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)
 572
 573         yield from self.terminate_nsr(nsr_id)
 574
 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)
 578
 579         self.verify_number_allocated_network(0)
 580         self.verify_number_allocated_compute(0)
 581
 582         self.unregister_mock_res_mgr()
 583         self.unpublish_descriptors()
 584
 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)
 590
 591         nsr_id = yield from self.ping_pong.create_nsr()
 592         yield from self.wait_until_nsr_active_or_failed(nsr_id)
 593
 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)
 598
 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")
 602
 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)
 607
 608         yield from self.terminate_nsr(nsr_id)
 609
 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)
 613
 614         self.verify_number_allocated_network(0)
 615         self.verify_number_allocated_compute(0)
 616
 617         self.unregister_mock_res_mgr()
 618         self.unpublish_descriptors()
 619
 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)
 625
 626         nsr_id = yield from self.ping_pong.create_nsr()
 627         yield from self.wait_until_nsr_active_or_failed(nsr_id)
 628
 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)
 633
 634         nsr_vlrs = yield from self.get_nsr_vlrs(nsr_id)
 635         yield from self.verify_vlr_state(nsr_vlrs[0], "running")
 636
 637         yield from self.verify_num_nsr_vnfrs(nsr_id, 2)
 638
 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")
 643
 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")
 647
 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)
 652
 653         yield from self.terminate_nsr(nsr_id)
 654
 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)
 658
 659         self.verify_number_allocated_network(0)
 660         self.verify_number_allocated_compute(0)
 661
 662         self.unregister_mock_res_mgr()
 663         self.unpublish_descriptors()
 664
 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)
 670
 671         nsr_id = yield from self.ping_pong.create_nsr()
 672         yield from self.wait_until_nsr_active_or_failed(nsr_id)
 673
 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)
 678
 679         nsr_vlrs = yield from self.get_nsr_vlrs(nsr_id)
 680         yield from self.verify_vlr_state(nsr_vlrs[0], "running")
 681
 682         yield from self.verify_num_nsr_vnfrs(nsr_id, 2)
 683
 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")
 688
 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")
 693
 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)
 698
 699         yield from self.terminate_nsr(nsr_id)
 700
 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)
 704
 705         self.verify_number_allocated_network(0)
 706         self.verify_number_allocated_compute(0)
 707
 708         self.unregister_mock_res_mgr()
 709         self.unpublish_descriptors()
 710
 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)
 717
 718         nsr_id = yield from self.ping_pong.create_nsr()
 719         yield from self.wait_until_nsr_active_or_failed(nsr_id)
 720
 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)
 725
 726         nsr_vlrs = yield from self.get_nsr_vlrs(nsr_id)
 727         yield from self.verify_vlr_state(nsr_vlrs[0], "running")
 728
 729         yield from self.verify_num_nsr_vnfrs(nsr_id, 2)
 730
 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")
 735
 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")
 740
 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")
 744
 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)
 749
 750         yield from self.terminate_nsr(nsr_id)
 751
 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)
 755
 756         self.verify_number_allocated_network(0)
 757         self.verify_number_allocated_compute(0)
 758
 759         self.unregister_mock_res_mgr()
 760         self.unpublish_descriptors()
 761
 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)
 769
 770         nsr_id = yield from self.ping_pong.create_nsr()
 771         yield from self.wait_until_nsr_active_or_failed(nsr_id)
 772
 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)
 777
 778         nsr_vlrs = yield from self.get_nsr_vlrs(nsr_id)
 779         yield from self.verify_vlr_state(nsr_vlrs[0], "running")
 780
 781         yield from self.verify_num_nsr_vnfrs(nsr_id, 2)
 782
 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")
 787
 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")
 792
 793         yield from self.verify_num_vnfr_vdus(nsr_vnfs[0], 2)
 794
 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")
 798
 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)
 803
 804         yield from self.terminate_nsr(nsr_id)
 805
 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)
 809
 810         self.verify_number_allocated_network(0)
 811         self.verify_number_allocated_compute(0)
 812
 813         self.unregister_mock_res_mgr()
 814         self.unpublish_descriptors()
 815
 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)
 823
 824         nsr_id = yield from self.ping_pong.create_nsr()
 825         yield from self.wait_until_nsr_active_or_failed(nsr_id)
 826
 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)
 831
 832         nsr_vlrs = yield from self.get_nsr_vlrs(nsr_id)
 833         yield from self.verify_vlr_state(nsr_vlrs[0], "running")
 834
 835         yield from self.verify_num_nsr_vnfrs(nsr_id, 2)
 836
 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")
 842
 843         yield from self.verify_num_vnfr_vlrs(nsr_vnfs[0], 2)
 844
 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")
 848
 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")
 852
 853         yield from self.verify_num_vnfr_vdus(nsr_vnfs[0], 2)
 854         yield from self.verify_num_vnfr_vdus(nsr_vnfs[1], 2)
 855
 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")
 859
 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")
 863
 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)
 868
 869         yield from self.terminate_nsr(nsr_id)
 870
 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)
 874
 875         self.verify_number_allocated_network(0)
 876         self.verify_number_allocated_compute(0)
 877
 878         self.unregister_mock_res_mgr()
 879         self.unpublish_descriptors()
 880
 881
 882 def main():
 883     runner = xmlrunner.XMLTestRunner(output=os.environ["RIFT_MODULE_TEST"])
 884
 885     parser = argparse.ArgumentParser()
 886     parser.add_argument('-v', '--verbose', action='store_true')
 887     args, _ = parser.parse_known_args()
 888
 889     ManoErrorTestCase.log_level = logging.DEBUG if args.verbose else logging.WARN
 890
 891     unittest.main(testRunner=runner)
 892
 893 if __name__ == '__main__':
 894     main()
 895
 896 # vim: sw