rwlaunchpad/plugins/rwresmgr/test/rmmgr_test.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
  20 import asyncio
  21 import logging
  22 import os
  23 import sys
  24 import types
  25 import unittest
  26 import uuid
  27 import random
  28
  29 import xmlrunner
  30
  31 import gi
  32 gi.require_version('CF', '1.0')
  33 gi.require_version('RwDts', '1.0')
  34 gi.require_version('RwMain', '1.0')
  35 gi.require_version('RwManifestYang', '1.0')
  36 gi.require_version('RwResourceMgrYang', '1.0')
  37 gi.require_version('RwcalYang', '1.0')
  38 gi.require_version('RwTypes', '1.0')
  39 gi.require_version('RwCal', '1.0')
  40
  41
  42 import gi.repository.CF as cf
  43 import gi.repository.RwDts as rwdts
  44 import gi.repository.RwMain as rwmain
  45 import gi.repository.RwManifestYang as rwmanifest
  46 import gi.repository.RwResourceMgrYang as rmgryang
  47 from gi.repository import RwcalYang
  48 from gi.repository import RwCloudYang
  49 from gi.repository.RwTypes import RwStatus
  50
  51 import rw_peas
  52 import rift.tasklets
  53 import rift.test.dts
  54
  55 if sys.version_info < (3, 4, 4):
  56     asyncio.ensure_future = asyncio.async
  57
  58
  59 openstack_info = {
  60     'username'      : 'pluto',
  61     'password'      : 'mypasswd',
  62     'auth_url'      : 'http://10.66.4.14:5000/v3/',
  63     'project_name'  : 'demo',
  64     'mgmt_network'  : 'private',
  65     'image_id'      : '5cece2b1-1a49-42c5-8029-833c56574652',
  66     'vms'           : ['res-test-1', 'res-test-2'],
  67     'networks'      : ['testnet1', 'testnet2']}
  68
  69
  70 def create_mock_resource_temaplate():
  71     ### Resource to be reuqested for 'mock'
  72     resource_requests = {'compute': {}, 'network': {}}
  73
  74     ###### mycompute-0
  75     msg = rmgryang.VDUEventData_RequestInfo()
  76     msg.image_id  = str(uuid.uuid3(uuid.NAMESPACE_DNS, 'image-0'))
  77     msg.vm_flavor.vcpu_count = 4
  78     msg.vm_flavor.memory_mb = 8192
  79     msg.vm_flavor.storage_gb = 40
  80     resource_requests['compute']['mycompute-0'] = msg
  81
  82     ###### mycompute-1
  83     msg = rmgryang.VDUEventData_RequestInfo()
  84     msg.image_id  = str(uuid.uuid3(uuid.NAMESPACE_DNS, 'image-1'))
  85     msg.vm_flavor.vcpu_count = 2
  86     msg.vm_flavor.memory_mb = 8192
  87     msg.vm_flavor.storage_gb = 20
  88     resource_requests['compute']['mycompute-1'] = msg
  89
  90     ####### mynet-0
  91     msg = rmgryang.VirtualLinkEventData_RequestInfo()
  92     resource_requests['network']['mynet-0'] = msg
  93
  94     ####### mynet-1
  95     msg = rmgryang.VirtualLinkEventData_RequestInfo()
  96     resource_requests['network']['mynet-1'] = msg
  97
  98     return resource_requests
  99
 100
 101 def create_cloudsim_resource_template():
 102     ### Resource to be reuqested for 'cloudsim'
 103     resource_requests = {'compute': {}, 'network': {}}
 104
 105     ###### mycompute-0
 106     msg = rmgryang.VDUEventData_RequestInfo()
 107     msg.image_id  = "1"
 108     msg.vm_flavor.vcpu_count = 4
 109     msg.vm_flavor.memory_mb = 8192
 110     msg.vm_flavor.storage_gb = 40
 111     resource_requests['compute']['mycompute-0'] = msg
 112
 113     ###### mycompute-1
 114     msg = rmgryang.VDUEventData_RequestInfo()
 115     msg.image_id  = "1"
 116     msg.vm_flavor.vcpu_count = 2
 117     msg.vm_flavor.memory_mb = 8192
 118     msg.vm_flavor.storage_gb = 20
 119     resource_requests['compute']['mycompute-1'] = msg
 120
 121     ####### mynet-0
 122     msg = rmgryang.VirtualLinkEventData_RequestInfo()
 123     resource_requests['network']['mynet-0'] = msg
 124
 125     ####### mynet-1
 126     msg = rmgryang.VirtualLinkEventData_RequestInfo()
 127     resource_requests['network']['mynet-1'] = msg
 128
 129     return resource_requests
 130
 131 def create_mock_resource_temaplate():
 132     ### Resource to be reuqested for 'mock'
 133     resource_requests = {'compute': {}, 'network': {}}
 134
 135     ###### mycompute-0
 136     msg = rmgryang.VDUEventData_RequestInfo()
 137     msg.image_id  = str(uuid.uuid3(uuid.NAMESPACE_DNS, 'image-0'))
 138     msg.vm_flavor.vcpu_count = 4
 139     msg.vm_flavor.memory_mb = 8192
 140     msg.vm_flavor.storage_gb = 40
 141     resource_requests['compute']['mycompute-0'] = msg
 142
 143     ###### mycompute-1
 144     msg = rmgryang.VDUEventData_RequestInfo()
 145     msg.image_id  = str(uuid.uuid3(uuid.NAMESPACE_DNS, 'image-1'))
 146     msg.vm_flavor.vcpu_count = 2
 147     msg.vm_flavor.memory_mb = 8192
 148     msg.vm_flavor.storage_gb = 20
 149     resource_requests['compute']['mycompute-1'] = msg
 150
 151     ####### mynet-0
 152     msg = rmgryang.VirtualLinkEventData_RequestInfo()
 153     resource_requests['network']['mynet-0'] = msg
 154
 155     ####### mynet-1
 156     msg = rmgryang.VirtualLinkEventData_RequestInfo()
 157     resource_requests['network']['mynet-1'] = msg
 158
 159     return resource_requests
 160
 161
 162 def create_openstack_static_template():
 163     ### Resource to be reuqested for 'openstack_static'
 164     resource_requests = {'compute': {}, 'network': {}}
 165
 166     ###### mycompute-0
 167     msg = rmgryang.VDUEventData_RequestInfo()
 168     msg.image_id  = openstack_info['image_id']
 169     msg.vm_flavor.vcpu_count = 4
 170     msg.vm_flavor.memory_mb = 8192
 171     msg.vm_flavor.storage_gb = 80
 172     resource_requests['compute']['mycompute-0'] = msg
 173
 174     ###### mycompute-1
 175     msg = rmgryang.VDUEventData_RequestInfo()
 176     msg.image_id  = openstack_info['image_id']
 177     msg.vm_flavor.vcpu_count = 2
 178     msg.vm_flavor.memory_mb = 4096
 179     msg.vm_flavor.storage_gb = 40
 180     resource_requests['compute']['mycompute-1'] = msg
 181
 182     ####### mynet-0
 183     msg = rmgryang.VirtualLinkEventData_RequestInfo()
 184     msg.provider_network.physical_network = 'PHYSNET1'
 185     msg.provider_network.overlay_type = 'VLAN'
 186     msg.provider_network.segmentation_id = 17
 187     resource_requests['network']['mynet-0'] = msg
 188
 189     ####### mynet-1
 190     msg = rmgryang.VirtualLinkEventData_RequestInfo()
 191     msg.provider_network.physical_network = 'PHYSNET1'
 192     msg.provider_network.overlay_type = 'VLAN'
 193     msg.provider_network.segmentation_id = 18
 194     resource_requests['network']['mynet-1'] = msg
 195
 196     return resource_requests
 197
 198
 199 def create_openstack_dynamic_template():
 200     ### Resource to be reuqested for 'openstack_dynamic'
 201     resource_requests = {'compute': {}, 'network': {}}
 202
 203     ###### mycompute-0
 204     msg = rmgryang.VDUEventData_RequestInfo()
 205     msg.image_id  = openstack_info['image_id']
 206     msg.vm_flavor.vcpu_count = 2
 207     msg.vm_flavor.memory_mb = 4096
 208     msg.vm_flavor.storage_gb = 40
 209     msg.guest_epa.mempage_size = 'LARGE'
 210     msg.guest_epa.cpu_pinning_policy = 'DEDICATED'
 211     msg.allocate_public_address = True
 212
 213     resource_requests['compute']['mycompute-0'] = msg
 214
 215     ###### mycompute-1
 216     msg = rmgryang.VDUEventData_RequestInfo()
 217     msg.image_id  = openstack_info['image_id']
 218     msg.vm_flavor.vcpu_count = 4
 219     msg.vm_flavor.memory_mb = 8192
 220     msg.vm_flavor.storage_gb = 40
 221     msg.guest_epa.mempage_size = 'LARGE'
 222     msg.guest_epa.cpu_pinning_policy = 'DEDICATED'
 223     msg.allocate_public_address = True
 224
 225     resource_requests['compute']['mycompute-1'] = msg
 226
 227     ####### mynet-0
 228     msg = rmgryang.VirtualLinkEventData_RequestInfo()
 229     #msg.provider_network.overlay_type = 'VXLAN'
 230     #msg.provider_network.segmentation_id = 71
 231
 232     resource_requests['network']['mynet-0'] = msg
 233
 234     ####### mynet-1
 235     msg = rmgryang.VirtualLinkEventData_RequestInfo()
 236     #msg.provider_network.overlay_type = 'VXLAN'
 237     #msg.provider_network.segmentation_id = 73
 238     resource_requests['network']['mynet-1'] = msg
 239
 240     return resource_requests
 241
 242
 243
 244
 245 resource_requests = {
 246     'mock' : create_mock_resource_temaplate(),
 247     'openstack_static': create_openstack_static_template(),
 248     'openstack_dynamic': create_openstack_dynamic_template(),
 249     'cloudsim': create_cloudsim_resource_template(),
 250 }
 251
 252
 253 def get_cal_account(account_type):
 254     """
 255     Creates an object for class RwcalYang.CloudAccount()
 256     """
 257     account = RwcalYang.CloudAccount()
 258     if account_type == 'mock':
 259         account.name          = 'mock_account'
 260         account.account_type  = "mock"
 261         account.mock.username = "mock_user"
 262     elif ((account_type == 'openstack_static') or (account_type == 'openstack_dynamic')):
 263         account.name = 'openstack_cal'
 264         account.account_type = 'openstack'
 265         account.openstack.key = openstack_info['username']
 266         account.openstack.secret       = openstack_info['password']
 267         account.openstack.auth_url     = openstack_info['auth_url']
 268         account.openstack.tenant       = openstack_info['project_name']
 269         account.openstack.mgmt_network = openstack_info['mgmt_network']
 270
 271     elif account_type == 'cloudsim':
 272         account.name          = 'cloudsim'
 273         account.account_type  = "cloudsim_proxy"
 274
 275     return account
 276
 277 def create_cal_plugin(account, log_hdl):
 278     plugin_name = getattr(account, account.account_type).plugin_name
 279     plugin = rw_peas.PeasPlugin(plugin_name, 'RwCal-1.0')
 280     engine, info, extension = plugin()
 281     rwcal = plugin.get_interface("Cloud")
 282     try:
 283         rc = rwcal.init(log_hdl)
 284         assert rc == RwStatus.SUCCESS
 285     except Exception as e:
 286         raise
 287     return rwcal
 288
 289
 290 class RMMgrTestCase(rift.test.dts.AbstractDTSTest):
 291     rwcal = None
 292     rwcal_acct_info = None
 293
 294     @classmethod
 295     def configure_suite(cls, rwmain):
 296         rm_dir = os.environ.get('RM_DIR')
 297         cnt_mgr_dir = os.environ.get('CNTR_MGR_DIR')
 298         cal_proxy_dir = os.environ.get('CAL_PROXY_DIR')
 299
 300         cls.rwmain.add_tasklet(cal_proxy_dir, 'rwcalproxytasklet')
 301         cls.rwmain.add_tasklet(rm_dir, 'rwresmgrtasklet')
 302         cls.rwmain.add_tasklet(cnt_mgr_dir, 'rwcntmgrtasklet')
 303
 304     @classmethod
 305     def configure_schema(cls):
 306         return rmgryang.get_schema()
 307
 308     @asyncio.coroutine
 309     def wait_tasklets(self):
 310         yield from asyncio.sleep(1, loop=self.loop)
 311
 312     @classmethod
 313     def configure_timeout(cls):
 314         return 360
 315
 316     def get_cloud_account_msg(self, acct_type):
 317         cloud_account = RwCloudYang.CloudAccount()
 318         acct = get_cal_account(acct_type)
 319         cloud_account.from_dict(acct.as_dict())
 320         cloud_account.name = acct.name
 321         return cloud_account
 322
 323     def get_compute_pool_msg(self, name, pool_type, cloud_type):
 324         pool_config = rmgryang.ResourcePools()
 325         pool = pool_config.pools.add()
 326         pool.name = name
 327         pool.resource_type = "compute"
 328         if pool_type == "static":
 329             pool.pool_type = 'static'
 330             acct = get_cal_account(cloud_type)
 331             rwcal = create_cal_plugin(acct, self.tinfo.get_rwlog_ctx())
 332             rc, rsp = rwcal.get_vdu_list(acct)
 333             assert rc == RwStatus.SUCCESS
 334
 335             if cloud_type == 'openstack_static':
 336                 for vdu in rsp.vdu_info_list:
 337                     if vdu.name in openstack_info['vms']:
 338                         self.log.info("Adding the static compute resource: %s to compute pool", vdu.name)
 339                         r = pool.resources.add()
 340                         r.resource_id = vdu.vdu_id
 341             else:
 342                 # 'mock', 'cloudsim' 'openstack_dynamic' etc
 343                 for vdu in rsp.vdu_info_list:
 344                     self.log.info("Adding the static compute resource: %s to compute pool", vdu.name)
 345                     r = pool.resources.add()
 346                     r.resource_id = vdu.vdu_id
 347         else:
 348             pool.pool_type = 'dynamic'
 349             pool.max_size = 10
 350         return pool_config
 351
 352     def get_network_pool_msg(self, name, pool_type, cloud_type):
 353         pool_config = rmgryang.ResourcePools()
 354         pool = pool_config.pools.add()
 355         pool.name = name
 356         pool.resource_type = "network"
 357         if pool_type == "static":
 358             pool.pool_type = 'static'
 359             acct = get_cal_account(cloud_type)
 360             rwcal = create_cal_plugin(acct, self.tinfo.get_rwlog_ctx())
 361             rc, rsp = rwcal.get_virtual_link_list(acct)
 362             assert rc == RwStatus.SUCCESS
 363             if cloud_type == 'openstack_static':
 364                 for vlink in rsp.virtual_link_info_list:
 365                     if vlink.name in openstack_info['networks']:
 366                         self.log.info("Adding the static network resource: %s to network pool", vlink.name)
 367                         r = pool.resources.add()
 368                         r.resource_id = vlink.virtual_link_id
 369             else:
 370                 # 'mock', 'cloudsim', 'openstack_dynamic' etc
 371                 for vlink in rsp.virtual_link_info_list:
 372                     self.log.info("Adding the static network resource: %s to network pool", vlink.name)
 373                     r = pool.resources.add()
 374                     r.resource_id = vlink.virtual_link_id
 375         else:
 376             pool.pool_type = 'dynamic'
 377             pool.max_size = 4
 378         return pool_config
 379
 380
 381     def get_network_reserve_msg(self, name, cloud_type, xpath):
 382         event_id = str(uuid.uuid4())
 383         msg = rmgryang.VirtualLinkEventData()
 384         msg.event_id = event_id
 385         msg.request_info.name = name
 386         attributes = ['physical_network', 'name', 'overlay_type', 'segmentation_id']
 387
 388         for attr in attributes:
 389             if resource_requests[cloud_type]['network'][name].has_field('provider_network'):
 390                 if resource_requests[cloud_type]['network'][name].provider_network.has_field(attr):
 391                     setattr(msg.request_info.provider_network, attr,
 392                             getattr(resource_requests[cloud_type]['network'][name].provider_network ,attr))
 393
 394         return msg, xpath.format(event_id)
 395
 396     def get_compute_reserve_msg(self, name, cloud_type, xpath, vlinks):
 397         event_id = str(uuid.uuid4())
 398         msg = rmgryang.VDUEventData()
 399         msg.event_id = event_id
 400         msg.request_info.name = name
 401         msg.request_info.image_id = resource_requests[cloud_type]['compute'][name].image_id
 402         attributes = ['image_id', 'vcpu_count', 'memory_mb', 'storage_gb']
 403
 404         if resource_requests[cloud_type]['compute'][name].has_field('vm_flavor'):
 405             for attr in attributes:
 406                 if resource_requests[cloud_type]['compute'][name].vm_flavor.has_field(attr):
 407                     setattr(msg.request_info.vm_flavor,
 408                             attr,
 409                             getattr(resource_requests[cloud_type]['compute'][name].vm_flavor , attr))
 410
 411         attributes = ['mempage_size', 'cpu_pinning_policy']
 412
 413         if resource_requests[cloud_type]['compute'][name].has_field('guest_epa'):
 414             for attr in attributes:
 415                 if resource_requests[cloud_type]['compute'][name].guest_epa.has_field(attr):
 416                     setattr(msg.request_info.guest_epa,
 417                             attr,
 418                             getattr(resource_requests[cloud_type]['compute'][name].guest_epa , attr))
 419
 420         if resource_requests[cloud_type]['compute'][name].has_field('allocate_public_address'):
 421             msg.request_info.allocate_public_address = resource_requests[cloud_type]['compute'][name].allocate_public_address
 422
 423         cnt = 0
 424         for link in vlinks:
 425             c1 = msg.request_info.connection_points.add()
 426             c1.name = name+"-port-"+str(cnt)
 427             cnt += 1
 428             c1.virtual_link_id = link
 429
 430         self.log.info("Sending message :%s", msg)
 431         return msg, xpath.format(event_id)
 432
 433     @asyncio.coroutine
 434     def configure_cloud_account(self, dts, acct_type):
 435         account_xpath = "C,/rw-cloud:cloud/account"
 436         msg = self.get_cloud_account_msg(acct_type)
 437         self.log.info("Configuring cloud-account: %s",msg)
 438         yield from dts.query_create(account_xpath,
 439                                     rwdts.XactFlag.ADVISE,
 440                                     msg)
 441
 442     @asyncio.coroutine
 443     def configure_compute_resource_pools(self, dts, resource_type, cloud_type):
 444         pool_xpath = "C,/rw-resource-mgr:resource-mgr-config/rw-resource-mgr:resource-pools"
 445         msg = self.get_compute_pool_msg("virtual-compute", resource_type, cloud_type)
 446         self.log.info("Configuring compute-resource-pool: %s",msg)
 447         yield from dts.query_create(pool_xpath,
 448                                     rwdts.XactFlag.ADVISE,
 449                                     msg)
 450
 451
 452     @asyncio.coroutine
 453     def configure_network_resource_pools(self, dts, resource_type, cloud_type):
 454         pool_xpath = "C,/rw-resource-mgr:resource-mgr-config/rw-resource-mgr:resource-pools"
 455         msg = self.get_network_pool_msg("virtual-network", resource_type, cloud_type)
 456         self.log.info("Configuring network-resource-pool: %s",msg)
 457         yield from dts.query_create(pool_xpath,
 458                                     rwdts.XactFlag.ADVISE,
 459                                     msg)
 460
 461     @asyncio.coroutine
 462     def verify_resource_pools_config(self, dts):
 463         pool_records_xpath = "D,/rw-resource-mgr:resource-pool-records"
 464         self.log.debug("Verifying test_create_resource_pools results")
 465         res_iter = yield from dts.query_read(pool_records_xpath,)
 466         for result in res_iter:
 467             response = yield from result
 468             records = response.result.records
 469             #self.assertEqual(len(records), 2)
 470             #names = [i.name for i in records]
 471             #self.assertTrue('virtual-compute' in names)
 472             #self.assertTrue('virtual-network' in names)
 473             for record in records:
 474                 self.log.debug("Received Pool Record, Name: %s, Resource Type: %s, Pool Status: %s, Pool Size: %d, Allocated Resources: %d, Free Resources: %d",
 475                                record.name,
 476                                record.resource_type,
 477                                record.pool_status,
 478                                record.total_resources,
 479                                record.allocated_resources,
 480                                record.free_resources)
 481
 482     @asyncio.coroutine
 483     def read_resource(self, dts, xpath):
 484         self.log.debug("Reading data for XPATH:%s", xpath)
 485         result = yield from dts.query_read(xpath, rwdts.XactFlag.MERGE)
 486         msg = None
 487         for r in result:
 488             msg = yield from r
 489         self.log.debug("Received data: %s", msg.result)
 490         return msg.result
 491
 492     @asyncio.coroutine
 493     def reserve_network_resources(self, name, dts, cloud_type):
 494         network_xpath = "D,/rw-resource-mgr:resource-mgmt/vlink-event/vlink-event-data[event-id='{}']"
 495         msg,xpath = self.get_network_reserve_msg(name, cloud_type, network_xpath)
 496         self.log.debug("Sending create event to network-event xpath %s with msg: %s" % (xpath, msg))
 497         yield from dts.query_create(xpath, 0, msg)
 498         return xpath
 499
 500
 501     @asyncio.coroutine
 502     def reserve_compute_resources(self, name, dts, cloud_type, vlinks = []):
 503         compute_xpath = "D,/rw-resource-mgr:resource-mgmt/vdu-event/vdu-event-data[event-id='{}']"
 504         msg,xpath = self.get_compute_reserve_msg(name, cloud_type, compute_xpath, vlinks)
 505         self.log.debug("Sending create event to compute-event xpath %s with msg: %s" % (xpath, msg))
 506         yield from dts.query_create(xpath, 0, msg)
 507         return xpath
 508
 509     @asyncio.coroutine
 510     def release_network_resources(self, dts, xpath):
 511         self.log.debug("Initiating network resource release for  : %s ", xpath)
 512         yield from dts.query_delete(xpath, 0)
 513
 514     @asyncio.coroutine
 515     def release_compute_resources(self, dts, xpath):
 516         self.log.debug("Initiating compute resource release for  : %s ", xpath)
 517         yield from dts.query_delete(xpath, 0)
 518
 519     @unittest.skip("Skipping test_static_pool_resource_allocation")
 520     def test_static_pool_resource_allocation(self):
 521         self.log.debug("STARTING - test_static_pool_resource_allocation")
 522         tinfo = self.new_tinfo('static_mock')
 523         dts = rift.tasklets.DTS(tinfo, self.schema, self.loop)
 524
 525         @asyncio.coroutine
 526         def run_test():
 527             networks = []
 528             computes = []
 529             cloud_type = 'mock'
 530             yield from self.wait_tasklets()
 531             yield from self.configure_cloud_account(dts, cloud_type)
 532
 533             yield from self.configure_network_resource_pools(dts, "static", cloud_type)
 534             yield from self.configure_compute_resource_pools(dts, "static", cloud_type)
 535             yield from self.verify_resource_pools_config(dts)
 536
 537             r_xpath = yield from self.reserve_network_resources('mynet-0', dts, cloud_type)
 538             r_info = yield from self.read_resource(dts,r_xpath)
 539             networks.append((r_xpath, r_info.resource_info))
 540
 541             for i in range(2):
 542                 r_xpath = yield from self.reserve_compute_resources("mycompute-"+str(i),
 543                                                                     dts,
 544                                                                     cloud_type,
 545                                                                     [networks[0][1].virtual_link_id])
 546                 r_info = yield from self.read_resource(dts,r_xpath)
 547                 computes.append((r_xpath, r_info))
 548
 549             yield from self.verify_resource_pools_config(dts)
 550
 551             for r in computes:
 552                 yield from self.release_compute_resources(dts, r[0])
 553
 554             yield from self.release_network_resources(dts,networks[0][0])
 555             yield from self.verify_resource_pools_config(dts)
 556
 557         future = asyncio.ensure_future(run_test(), loop=self.loop)
 558         self.run_until(future.done)
 559         if future.exception() is not None:
 560             self.log.error("Caught exception during test")
 561             raise future.exception()
 562
 563         self.log.debug("DONE - test_static_pool_resource_allocation")
 564
 565     @unittest.skip("Skipping test_dynamic_pool_resource_allocation")
 566     def test_dynamic_pool_resource_allocation(self):
 567         self.log.debug("STARTING - test_dynamic_pool_resource_allocation")
 568         tinfo = self.new_tinfo('dynamic_mock')
 569         dts = rift.tasklets.DTS(tinfo, self.schema, self.loop)
 570
 571         @asyncio.coroutine
 572         def run_test():
 573             networks = []
 574             computes = []
 575             cloud_type = 'mock'
 576             yield from self.wait_tasklets()
 577             yield from self.configure_cloud_account(dts, cloud_type)
 578             yield from self.configure_network_resource_pools(dts, "dynamic", cloud_type)
 579             yield from self.configure_compute_resource_pools(dts, "dynamic", cloud_type)
 580             yield from self.verify_resource_pools_config(dts)
 581
 582             r_xpath = yield from self.reserve_network_resources('mynet-0', dts, cloud_type)
 583             r_info = yield from self.read_resource(dts,r_xpath)
 584             networks.append((r_xpath, r_info.resource_info))
 585
 586             for i in range(2):
 587                 r_xpath = yield from self.reserve_compute_resources("mycompute-"+str(i),
 588                                                                     dts,
 589                                                                     cloud_type,
 590                                                                     [networks[0][1].virtual_link_id])
 591                 r_info = yield from self.read_resource(dts,r_xpath)
 592                 computes.append((r_xpath, r_info))
 593
 594             yield from self.verify_resource_pools_config(dts)
 595
 596             for r in computes:
 597                 self.log.debug("Releasing compute resource with id: %s", r[1].resource_info.vdu_id)
 598                 yield from self.release_compute_resources(dts, r[0])
 599
 600             yield from self.release_network_resources(dts,networks[0][0])
 601             yield from self.verify_resource_pools_config(dts)
 602
 603         future = asyncio.ensure_future(run_test(), loop=self.loop)
 604         self.run_until(future.done)
 605         if future.exception() is not None:
 606             self.log.error("Caught exception during test")
 607             raise future.exception()
 608
 609         self.log.debug("DONE - test_dynamic_pool_resource_allocation")
 610
 611     @unittest.skip("Skipping test_dynamic_pool_resource_allocation")
 612     def test_dynamic_cloudsim_pool_resource_allocation(self):
 613         self.log.debug("STARTING - test_dynamic_pool_resource_allocation")
 614         tinfo = self.new_tinfo('dynamic_mock')
 615         dts = rift.tasklets.DTS(tinfo, self.schema, self.loop)
 616
 617         @asyncio.coroutine
 618         def run_test():
 619             networks = []
 620             computes = []
 621             cloud_type = 'cloudsim'
 622
 623             yield from asyncio.sleep(120, loop=self.loop)
 624             yield from self.configure_cloud_account(dts, cloud_type)
 625             yield from self.configure_network_resource_pools(dts, "dynamic", cloud_type)
 626             yield from self.configure_compute_resource_pools(dts, "dynamic", cloud_type)
 627             yield from self.verify_resource_pools_config(dts)
 628
 629             r_xpath = yield from self.reserve_network_resources('mynet-0', dts, cloud_type)
 630             r_info = yield from self.read_resource(dts,r_xpath)
 631             networks.append((r_xpath, r_info.resource_info))
 632
 633             for i in range(2):
 634                 r_xpath = yield from self.reserve_compute_resources("mycompute-"+str(i),
 635                                                                     dts,
 636                                                                     cloud_type,
 637                                                                     [networks[0][1].virtual_link_id])
 638                 r_info = yield from self.read_resource(dts,r_xpath)
 639                 computes.append((r_xpath, r_info))
 640
 641             yield from self.verify_resource_pools_config(dts)
 642
 643             for r in computes:
 644                 self.log.debug("Releasing compute resource with id: %s", r[1].resource_info.vdu_id)
 645                 yield from self.release_compute_resources(dts, r[0])
 646
 647             yield from self.release_network_resources(dts,networks[0][0])
 648             yield from self.verify_resource_pools_config(dts)
 649
 650         future = asyncio.ensure_future(run_test(), loop=self.loop)
 651         self.run_until(future.done)
 652         if future.exception() is not None:
 653             self.log.error("Caught exception during test")
 654             raise future.exception()
 655
 656         self.log.debug("DONE - test_dynamic_pool_resource_allocation")
 657
 658     @unittest.skip("Skipping test_static_pool_openstack_resource_allocation")
 659     def test_static_pool_openstack_resource_allocation(self):
 660         self.log.debug("STARTING - test_static_pool_openstack_resource_allocation")
 661         tinfo = self.new_tinfo('static_openstack')
 662         dts = rift.tasklets.DTS(tinfo, self.schema, self.loop)
 663
 664         @asyncio.coroutine
 665         def run_test():
 666             networks = []
 667             computes = []
 668             cloud_type = 'openstack_static'
 669             yield from self.wait_tasklets()
 670             yield from self.configure_cloud_account(dts, cloud_type)
 671             yield from self.configure_network_resource_pools(dts, "static", cloud_type)
 672             yield from self.configure_compute_resource_pools(dts, "static", cloud_type)
 673             yield from self.verify_resource_pools_config(dts)
 674
 675             self.log.debug("Creating virtual-network-resources in openstack")
 676             r_xpath = yield from self.reserve_network_resources('mynet-0', dts, cloud_type)
 677             r_info = yield from self.read_resource(dts,r_xpath)
 678             networks.append((r_xpath, r_info.resource_info))
 679             self.log.debug("virtual-network-resources successfully created in openstack")
 680
 681             self.log.debug("Creating virtual-network-compute in openstack")
 682             for i in range(2):
 683                 r_xpath = yield from self.reserve_compute_resources("mycompute-" + str(i),
 684                                                                     dts,
 685                                                                     cloud_type,
 686                                                                     [networks[0][1].virtual_link_id])
 687                 r_info = yield from self.read_resource(dts,r_xpath)
 688                 computes.append((r_xpath, r_info))
 689
 690             yield from self.verify_resource_pools_config(dts)
 691             for r in computes:
 692                 self.log.debug("Releasing compute resource with id: %s", r[1].resource_info.vdu_id)
 693                 yield from self.release_compute_resources(dts, r[0])
 694
 695             yield from self.release_network_resources(dts,networks[0][0])
 696             yield from self.verify_resource_pools_config(dts)
 697             self.log.debug("Openstack static resource allocation completed")
 698
 699         future = asyncio.ensure_future(run_test(), loop=self.loop)
 700         self.run_until(future.done)
 701         if future.exception() is not None:
 702             self.log.error("Caught exception during test")
 703             raise future.exception()
 704
 705         self.log.debug("DONE - test_static_pool_openstack_resource_allocation")
 706
 707     #@unittest.skip("Skipping test_dynamic_pool_openstack_resource_allocation")
 708     def test_dynamic_pool_openstack_resource_allocation(self):
 709         self.log.debug("STARTING - test_dynamic_pool_openstack_resource_allocation")
 710         tinfo = self.new_tinfo('dynamic_openstack')
 711         dts = rift.tasklets.DTS(tinfo, self.schema, self.loop)
 712
 713         @asyncio.coroutine
 714         def run_test():
 715             networks = []
 716             computes = []
 717             cloud_type = 'openstack_dynamic'
 718             yield from self.wait_tasklets()
 719             yield from self.configure_cloud_account(dts, cloud_type)
 720             yield from self.configure_network_resource_pools(dts, "dynamic", cloud_type)
 721             yield from self.configure_compute_resource_pools(dts, "dynamic", cloud_type)
 722             yield from self.verify_resource_pools_config(dts)
 723
 724             self.log.debug("Creating virtual-network-resources in openstack")
 725             r_xpath = yield from self.reserve_network_resources('mynet-0', dts, cloud_type)
 726             r_info = yield from self.read_resource(dts,r_xpath)
 727             networks.append((r_xpath, r_info.resource_info))
 728             self.log.debug("virtual-network-resources successfully created in openstack")
 729
 730             self.log.debug("Creating virtual-network-compute in openstack")
 731             for i in range(2):
 732                 r_xpath = yield from self.reserve_compute_resources("mycompute-" + str(i),
 733                                                                     dts,
 734                                                                     cloud_type,
 735                                                                     [networks[0][1].virtual_link_id])
 736                 r_info = yield from self.read_resource(dts,r_xpath)
 737                 computes.append((r_xpath, r_info))
 738
 739             yield from self.verify_resource_pools_config(dts)
 740             for r in computes:
 741                 self.log.debug("Releasing compute resource with id: %s", r[1].resource_info.vdu_id)
 742                 #yield from self.release_compute_resources(dts, r[0])
 743
 744             self.log.debug("Releasing network resource with id: %s", r[1].resource_info.vdu_id)
 745             #yield from self.release_network_resources(dts,networks[0][0])
 746             #yield from self.verify_resource_pools_config(dts)
 747             self.log.debug("Openstack dynamic resource allocation completed")
 748
 749         future = asyncio.ensure_future(run_test(), loop=self.loop)
 750         self.run_until(future.done)
 751         if future.exception() is not None:
 752             self.log.error("Caught exception during test")
 753             raise future.exception()
 754
 755         self.log.debug("DONE - test_dynamic_pool_openstack_resource_allocation")
 756
 757
 758 def main():
 759     plugin_dir = os.path.join(os.environ["RIFT_INSTALL"], "usr/lib/rift/plugins")
 760
 761     if 'MESSAGE_BROKER_DIR' not in os.environ:
 762         os.environ['MESSAGE_BROKER_DIR'] = os.path.join(plugin_dir, 'rwmsgbroker-c')
 763
 764     if 'ROUTER_DIR' not in os.environ:
 765         os.environ['ROUTER_DIR'] = os.path.join(plugin_dir, 'rwdtsrouter-c')
 766
 767     if 'RM_DIR' not in os.environ:
 768         os.environ['RM_DIR'] = os.path.join(plugin_dir, 'rwresmgrtasklet')
 769
 770     if 'CAL_PROXY_DIR' not in os.environ:
 771         os.environ['CAL_PROXY_DIR'] = os.path.join(plugin_dir, 'rwcalproxytasklet')
 772
 773     if 'CNTR_MGR_DIR' not in os.environ:
 774         os.environ['CNTR_MGR_DIR'] = os.path.join(plugin_dir, 'rwcntmgrtasklet')
 775
 776     runner = xmlrunner.XMLTestRunner(output=os.environ["RIFT_MODULE_TEST"])
 777     unittest.main(testRunner=runner)
 778
 779 if __name__ == '__main__':
 780     main()
 781