--- /dev/null
+#!/usr/bin/env python3
+
+#
+# Copyright 2016 RIFT.IO Inc
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+import asyncio
+import logging
+import os
+import sys
+import types
+import unittest
+import uuid
+import random
+
+import xmlrunner
+
+import gi
+gi.require_version('CF', '1.0')
+gi.require_version('RwDts', '1.0')
+gi.require_version('RwMain', '1.0')
+gi.require_version('RwManifestYang', '1.0')
+gi.require_version('RwResourceMgrYang', '1.0')
+gi.require_version('RwcalYang', '1.0')
+gi.require_version('RwTypes', '1.0')
+gi.require_version('RwCal', '1.0')
+
+
+import gi.repository.CF as cf
+import gi.repository.RwDts as rwdts
+import gi.repository.RwMain as rwmain
+import gi.repository.RwManifestYang as rwmanifest
+import gi.repository.RwResourceMgrYang as rmgryang
+from gi.repository import RwcalYang
+from gi.repository import RwCloudYang
+from gi.repository.RwTypes import RwStatus
+
+import rw_peas
+import rift.tasklets
+import rift.test.dts
+
+if sys.version_info < (3, 4, 4):
+ asyncio.ensure_future = asyncio.async
+
+
+openstack_info = {
+ 'username' : 'pluto',
+ 'password' : 'mypasswd',
+ 'auth_url' : 'http://10.66.4.14:5000/v3/',
+ 'project_name' : 'demo',
+ 'mgmt_network' : 'private',
+ 'image_id' : '5cece2b1-1a49-42c5-8029-833c56574652',
+ 'vms' : ['res-test-1', 'res-test-2'],
+ 'networks' : ['testnet1', 'testnet2']}
+
+
+def create_mock_resource_temaplate():
+ ### Resource to be reuqested for 'mock'
+ resource_requests = {'compute': {}, 'network': {}}
+
+ ###### mycompute-0
+ msg = rmgryang.VDUEventData_RequestInfo()
+ msg.image_id = str(uuid.uuid3(uuid.NAMESPACE_DNS, 'image-0'))
+ msg.vm_flavor.vcpu_count = 4
+ msg.vm_flavor.memory_mb = 8192
+ msg.vm_flavor.storage_gb = 40
+ resource_requests['compute']['mycompute-0'] = msg
+
+ ###### mycompute-1
+ msg = rmgryang.VDUEventData_RequestInfo()
+ msg.image_id = str(uuid.uuid3(uuid.NAMESPACE_DNS, 'image-1'))
+ msg.vm_flavor.vcpu_count = 2
+ msg.vm_flavor.memory_mb = 8192
+ msg.vm_flavor.storage_gb = 20
+ resource_requests['compute']['mycompute-1'] = msg
+
+ ####### mynet-0
+ msg = rmgryang.VirtualLinkEventData_RequestInfo()
+ resource_requests['network']['mynet-0'] = msg
+
+ ####### mynet-1
+ msg = rmgryang.VirtualLinkEventData_RequestInfo()
+ resource_requests['network']['mynet-1'] = msg
+
+ return resource_requests
+
+
+def create_cloudsim_resource_template():
+ ### Resource to be reuqested for 'cloudsim'
+ resource_requests = {'compute': {}, 'network': {}}
+
+ ###### mycompute-0
+ msg = rmgryang.VDUEventData_RequestInfo()
+ msg.image_id = "1"
+ msg.vm_flavor.vcpu_count = 4
+ msg.vm_flavor.memory_mb = 8192
+ msg.vm_flavor.storage_gb = 40
+ resource_requests['compute']['mycompute-0'] = msg
+
+ ###### mycompute-1
+ msg = rmgryang.VDUEventData_RequestInfo()
+ msg.image_id = "1"
+ msg.vm_flavor.vcpu_count = 2
+ msg.vm_flavor.memory_mb = 8192
+ msg.vm_flavor.storage_gb = 20
+ resource_requests['compute']['mycompute-1'] = msg
+
+ ####### mynet-0
+ msg = rmgryang.VirtualLinkEventData_RequestInfo()
+ resource_requests['network']['mynet-0'] = msg
+
+ ####### mynet-1
+ msg = rmgryang.VirtualLinkEventData_RequestInfo()
+ resource_requests['network']['mynet-1'] = msg
+
+ return resource_requests
+
+def create_mock_resource_temaplate():
+ ### Resource to be reuqested for 'mock'
+ resource_requests = {'compute': {}, 'network': {}}
+
+ ###### mycompute-0
+ msg = rmgryang.VDUEventData_RequestInfo()
+ msg.image_id = str(uuid.uuid3(uuid.NAMESPACE_DNS, 'image-0'))
+ msg.vm_flavor.vcpu_count = 4
+ msg.vm_flavor.memory_mb = 8192
+ msg.vm_flavor.storage_gb = 40
+ resource_requests['compute']['mycompute-0'] = msg
+
+ ###### mycompute-1
+ msg = rmgryang.VDUEventData_RequestInfo()
+ msg.image_id = str(uuid.uuid3(uuid.NAMESPACE_DNS, 'image-1'))
+ msg.vm_flavor.vcpu_count = 2
+ msg.vm_flavor.memory_mb = 8192
+ msg.vm_flavor.storage_gb = 20
+ resource_requests['compute']['mycompute-1'] = msg
+
+ ####### mynet-0
+ msg = rmgryang.VirtualLinkEventData_RequestInfo()
+ resource_requests['network']['mynet-0'] = msg
+
+ ####### mynet-1
+ msg = rmgryang.VirtualLinkEventData_RequestInfo()
+ resource_requests['network']['mynet-1'] = msg
+
+ return resource_requests
+
+
+def create_openstack_static_template():
+ ### Resource to be reuqested for 'openstack_static'
+ resource_requests = {'compute': {}, 'network': {}}
+
+ ###### mycompute-0
+ msg = rmgryang.VDUEventData_RequestInfo()
+ msg.image_id = openstack_info['image_id']
+ msg.vm_flavor.vcpu_count = 4
+ msg.vm_flavor.memory_mb = 8192
+ msg.vm_flavor.storage_gb = 80
+ resource_requests['compute']['mycompute-0'] = msg
+
+ ###### mycompute-1
+ msg = rmgryang.VDUEventData_RequestInfo()
+ msg.image_id = openstack_info['image_id']
+ msg.vm_flavor.vcpu_count = 2
+ msg.vm_flavor.memory_mb = 4096
+ msg.vm_flavor.storage_gb = 40
+ resource_requests['compute']['mycompute-1'] = msg
+
+ ####### mynet-0
+ msg = rmgryang.VirtualLinkEventData_RequestInfo()
+ msg.provider_network.physical_network = 'PHYSNET1'
+ msg.provider_network.overlay_type = 'VLAN'
+ msg.provider_network.segmentation_id = 17
+ resource_requests['network']['mynet-0'] = msg
+
+ ####### mynet-1
+ msg = rmgryang.VirtualLinkEventData_RequestInfo()
+ msg.provider_network.physical_network = 'PHYSNET1'
+ msg.provider_network.overlay_type = 'VLAN'
+ msg.provider_network.segmentation_id = 18
+ resource_requests['network']['mynet-1'] = msg
+
+ return resource_requests
+
+
+def create_openstack_dynamic_template():
+ ### Resource to be reuqested for 'openstack_dynamic'
+ resource_requests = {'compute': {}, 'network': {}}
+
+ ###### mycompute-0
+ msg = rmgryang.VDUEventData_RequestInfo()
+ msg.image_id = openstack_info['image_id']
+ msg.vm_flavor.vcpu_count = 2
+ msg.vm_flavor.memory_mb = 4096
+ msg.vm_flavor.storage_gb = 40
+ msg.guest_epa.mempage_size = 'LARGE'
+ msg.guest_epa.cpu_pinning_policy = 'DEDICATED'
+ msg.allocate_public_address = True
+
+ resource_requests['compute']['mycompute-0'] = msg
+
+ ###### mycompute-1
+ msg = rmgryang.VDUEventData_RequestInfo()
+ msg.image_id = openstack_info['image_id']
+ msg.vm_flavor.vcpu_count = 4
+ msg.vm_flavor.memory_mb = 8192
+ msg.vm_flavor.storage_gb = 40
+ msg.guest_epa.mempage_size = 'LARGE'
+ msg.guest_epa.cpu_pinning_policy = 'DEDICATED'
+ msg.allocate_public_address = True
+
+ resource_requests['compute']['mycompute-1'] = msg
+
+ ####### mynet-0
+ msg = rmgryang.VirtualLinkEventData_RequestInfo()
+ #msg.provider_network.overlay_type = 'VXLAN'
+ #msg.provider_network.segmentation_id = 71
+
+ resource_requests['network']['mynet-0'] = msg
+
+ ####### mynet-1
+ msg = rmgryang.VirtualLinkEventData_RequestInfo()
+ #msg.provider_network.overlay_type = 'VXLAN'
+ #msg.provider_network.segmentation_id = 73
+ resource_requests['network']['mynet-1'] = msg
+
+ return resource_requests
+
+
+
+
+resource_requests = {
+ 'mock' : create_mock_resource_temaplate(),
+ 'openstack_static': create_openstack_static_template(),
+ 'openstack_dynamic': create_openstack_dynamic_template(),
+ 'cloudsim': create_cloudsim_resource_template(),
+}
+
+
+def get_cal_account(account_type):
+ """
+ Creates an object for class RwcalYang.CloudAccount()
+ """
+ account = RwcalYang.CloudAccount()
+ if account_type == 'mock':
+ account.name = 'mock_account'
+ account.account_type = "mock"
+ account.mock.username = "mock_user"
+ elif ((account_type == 'openstack_static') or (account_type == 'openstack_dynamic')):
+ account.name = 'openstack_cal'
+ account.account_type = 'openstack'
+ account.openstack.key = openstack_info['username']
+ account.openstack.secret = openstack_info['password']
+ account.openstack.auth_url = openstack_info['auth_url']
+ account.openstack.tenant = openstack_info['project_name']
+ account.openstack.mgmt_network = openstack_info['mgmt_network']
+
+ elif account_type == 'cloudsim':
+ account.name = 'cloudsim'
+ account.account_type = "cloudsim_proxy"
+
+ return account
+
+def create_cal_plugin(account, log_hdl):
+ plugin_name = getattr(account, account.account_type).plugin_name
+ plugin = rw_peas.PeasPlugin(plugin_name, 'RwCal-1.0')
+ engine, info, extension = plugin()
+ rwcal = plugin.get_interface("Cloud")
+ try:
+ rc = rwcal.init(log_hdl)
+ assert rc == RwStatus.SUCCESS
+ except Exception as e:
+ raise
+ return rwcal
+
+
+class RMMgrTestCase(rift.test.dts.AbstractDTSTest):
+ rwcal = None
+ rwcal_acct_info = None
+
+ @classmethod
+ def configure_suite(cls, rwmain):
+ rm_dir = os.environ.get('RM_DIR')
+ cnt_mgr_dir = os.environ.get('CNTR_MGR_DIR')
+ cal_proxy_dir = os.environ.get('CAL_PROXY_DIR')
+
+ cls.rwmain.add_tasklet(cal_proxy_dir, 'rwcalproxytasklet')
+ cls.rwmain.add_tasklet(rm_dir, 'rwresmgrtasklet')
+ cls.rwmain.add_tasklet(cnt_mgr_dir, 'rwcntmgrtasklet')
+
+ @classmethod
+ def configure_schema(cls):
+ return rmgryang.get_schema()
+
+ @asyncio.coroutine
+ def wait_tasklets(self):
+ yield from asyncio.sleep(1, loop=self.loop)
+
+ @classmethod
+ def configure_timeout(cls):
+ return 360
+
+ def get_cloud_account_msg(self, acct_type):
+ cloud_account = RwCloudYang.CloudAccount()
+ acct = get_cal_account(acct_type)
+ cloud_account.from_dict(acct.as_dict())
+ cloud_account.name = acct.name
+ return cloud_account
+
+ def get_compute_pool_msg(self, name, pool_type, cloud_type):
+ pool_config = rmgryang.ResourcePools()
+ pool = pool_config.pools.add()
+ pool.name = name
+ pool.resource_type = "compute"
+ if pool_type == "static":
+ pool.pool_type = 'static'
+ acct = get_cal_account(cloud_type)
+ rwcal = create_cal_plugin(acct, self.tinfo.get_rwlog_ctx())
+ rc, rsp = rwcal.get_vdu_list(acct)
+ assert rc == RwStatus.SUCCESS
+
+ if cloud_type == 'openstack_static':
+ for vdu in rsp.vdu_info_list:
+ if vdu.name in openstack_info['vms']:
+ self.log.info("Adding the static compute resource: %s to compute pool", vdu.name)
+ r = pool.resources.add()
+ r.resource_id = vdu.vdu_id
+ else:
+ # 'mock', 'cloudsim' 'openstack_dynamic' etc
+ for vdu in rsp.vdu_info_list:
+ self.log.info("Adding the static compute resource: %s to compute pool", vdu.name)
+ r = pool.resources.add()
+ r.resource_id = vdu.vdu_id
+ else:
+ pool.pool_type = 'dynamic'
+ pool.max_size = 10
+ return pool_config
+
+ def get_network_pool_msg(self, name, pool_type, cloud_type):
+ pool_config = rmgryang.ResourcePools()
+ pool = pool_config.pools.add()
+ pool.name = name
+ pool.resource_type = "network"
+ if pool_type == "static":
+ pool.pool_type = 'static'
+ acct = get_cal_account(cloud_type)
+ rwcal = create_cal_plugin(acct, self.tinfo.get_rwlog_ctx())
+ rc, rsp = rwcal.get_virtual_link_list(acct)
+ assert rc == RwStatus.SUCCESS
+ if cloud_type == 'openstack_static':
+ for vlink in rsp.virtual_link_info_list:
+ if vlink.name in openstack_info['networks']:
+ self.log.info("Adding the static network resource: %s to network pool", vlink.name)
+ r = pool.resources.add()
+ r.resource_id = vlink.virtual_link_id
+ else:
+ # 'mock', 'cloudsim', 'openstack_dynamic' etc
+ for vlink in rsp.virtual_link_info_list:
+ self.log.info("Adding the static network resource: %s to network pool", vlink.name)
+ r = pool.resources.add()
+ r.resource_id = vlink.virtual_link_id
+ else:
+ pool.pool_type = 'dynamic'
+ pool.max_size = 4
+ return pool_config
+
+
+ def get_network_reserve_msg(self, name, cloud_type, xpath):
+ event_id = str(uuid.uuid4())
+ msg = rmgryang.VirtualLinkEventData()
+ msg.event_id = event_id
+ msg.request_info.name = name
+ attributes = ['physical_network', 'name', 'overlay_type', 'segmentation_id']
+
+ for attr in attributes:
+ if resource_requests[cloud_type]['network'][name].has_field('provider_network'):
+ if resource_requests[cloud_type]['network'][name].provider_network.has_field(attr):
+ setattr(msg.request_info.provider_network, attr,
+ getattr(resource_requests[cloud_type]['network'][name].provider_network ,attr))
+
+ return msg, xpath.format(event_id)
+
+ def get_compute_reserve_msg(self, name, cloud_type, xpath, vlinks):
+ event_id = str(uuid.uuid4())
+ msg = rmgryang.VDUEventData()
+ msg.event_id = event_id
+ msg.request_info.name = name
+ msg.request_info.image_id = resource_requests[cloud_type]['compute'][name].image_id
+ attributes = ['image_id', 'vcpu_count', 'memory_mb', 'storage_gb']
+
+ if resource_requests[cloud_type]['compute'][name].has_field('vm_flavor'):
+ for attr in attributes:
+ if resource_requests[cloud_type]['compute'][name].vm_flavor.has_field(attr):
+ setattr(msg.request_info.vm_flavor,
+ attr,
+ getattr(resource_requests[cloud_type]['compute'][name].vm_flavor , attr))
+
+ attributes = ['mempage_size', 'cpu_pinning_policy']
+
+ if resource_requests[cloud_type]['compute'][name].has_field('guest_epa'):
+ for attr in attributes:
+ if resource_requests[cloud_type]['compute'][name].guest_epa.has_field(attr):
+ setattr(msg.request_info.guest_epa,
+ attr,
+ getattr(resource_requests[cloud_type]['compute'][name].guest_epa , attr))
+
+ if resource_requests[cloud_type]['compute'][name].has_field('allocate_public_address'):
+ msg.request_info.allocate_public_address = resource_requests[cloud_type]['compute'][name].allocate_public_address
+
+ cnt = 0
+ for link in vlinks:
+ c1 = msg.request_info.connection_points.add()
+ c1.name = name+"-port-"+str(cnt)
+ cnt += 1
+ c1.virtual_link_id = link
+
+ self.log.info("Sending message :%s", msg)
+ return msg, xpath.format(event_id)
+
+ @asyncio.coroutine
+ def configure_cloud_account(self, dts, acct_type):
+ account_xpath = "C,/rw-cloud:cloud/account"
+ msg = self.get_cloud_account_msg(acct_type)
+ self.log.info("Configuring cloud-account: %s",msg)
+ yield from dts.query_create(account_xpath,
+ rwdts.XactFlag.ADVISE,
+ msg)
+
+ @asyncio.coroutine
+ def configure_compute_resource_pools(self, dts, resource_type, cloud_type):
+ pool_xpath = "C,/rw-resource-mgr:resource-mgr-config/rw-resource-mgr:resource-pools"
+ msg = self.get_compute_pool_msg("virtual-compute", resource_type, cloud_type)
+ self.log.info("Configuring compute-resource-pool: %s",msg)
+ yield from dts.query_create(pool_xpath,
+ rwdts.XactFlag.ADVISE,
+ msg)
+
+
+ @asyncio.coroutine
+ def configure_network_resource_pools(self, dts, resource_type, cloud_type):
+ pool_xpath = "C,/rw-resource-mgr:resource-mgr-config/rw-resource-mgr:resource-pools"
+ msg = self.get_network_pool_msg("virtual-network", resource_type, cloud_type)
+ self.log.info("Configuring network-resource-pool: %s",msg)
+ yield from dts.query_create(pool_xpath,
+ rwdts.XactFlag.ADVISE,
+ msg)
+
+ @asyncio.coroutine
+ def verify_resource_pools_config(self, dts):
+ pool_records_xpath = "D,/rw-resource-mgr:resource-pool-records"
+ self.log.debug("Verifying test_create_resource_pools results")
+ res_iter = yield from dts.query_read(pool_records_xpath,)
+ for result in res_iter:
+ response = yield from result
+ records = response.result.records
+ #self.assertEqual(len(records), 2)
+ #names = [i.name for i in records]
+ #self.assertTrue('virtual-compute' in names)
+ #self.assertTrue('virtual-network' in names)
+ for record in records:
+ self.log.debug("Received Pool Record, Name: %s, Resource Type: %s, Pool Status: %s, Pool Size: %d, Allocated Resources: %d, Free Resources: %d",
+ record.name,
+ record.resource_type,
+ record.pool_status,
+ record.total_resources,
+ record.allocated_resources,
+ record.free_resources)
+
+ @asyncio.coroutine
+ def read_resource(self, dts, xpath):
+ self.log.debug("Reading data for XPATH:%s", xpath)
+ result = yield from dts.query_read(xpath, rwdts.XactFlag.MERGE)
+ msg = None
+ for r in result:
+ msg = yield from r
+ self.log.debug("Received data: %s", msg.result)
+ return msg.result
+
+ @asyncio.coroutine
+ def reserve_network_resources(self, name, dts, cloud_type):
+ network_xpath = "D,/rw-resource-mgr:resource-mgmt/vlink-event/vlink-event-data[event-id='{}']"
+ msg,xpath = self.get_network_reserve_msg(name, cloud_type, network_xpath)
+ self.log.debug("Sending create event to network-event xpath %s with msg: %s" % (xpath, msg))
+ yield from dts.query_create(xpath, 0, msg)
+ return xpath
+
+
+ @asyncio.coroutine
+ def reserve_compute_resources(self, name, dts, cloud_type, vlinks = []):
+ compute_xpath = "D,/rw-resource-mgr:resource-mgmt/vdu-event/vdu-event-data[event-id='{}']"
+ msg,xpath = self.get_compute_reserve_msg(name, cloud_type, compute_xpath, vlinks)
+ self.log.debug("Sending create event to compute-event xpath %s with msg: %s" % (xpath, msg))
+ yield from dts.query_create(xpath, 0, msg)
+ return xpath
+
+ @asyncio.coroutine
+ def release_network_resources(self, dts, xpath):
+ self.log.debug("Initiating network resource release for : %s ", xpath)
+ yield from dts.query_delete(xpath, 0)
+
+ @asyncio.coroutine
+ def release_compute_resources(self, dts, xpath):
+ self.log.debug("Initiating compute resource release for : %s ", xpath)
+ yield from dts.query_delete(xpath, 0)
+
+ @unittest.skip("Skipping test_static_pool_resource_allocation")
+ def test_static_pool_resource_allocation(self):
+ self.log.debug("STARTING - test_static_pool_resource_allocation")
+ tinfo = self.new_tinfo('static_mock')
+ dts = rift.tasklets.DTS(tinfo, self.schema, self.loop)
+
+ @asyncio.coroutine
+ def run_test():
+ networks = []
+ computes = []
+ cloud_type = 'mock'
+ yield from self.wait_tasklets()
+ yield from self.configure_cloud_account(dts, cloud_type)
+
+ yield from self.configure_network_resource_pools(dts, "static", cloud_type)
+ yield from self.configure_compute_resource_pools(dts, "static", cloud_type)
+ yield from self.verify_resource_pools_config(dts)
+
+ r_xpath = yield from self.reserve_network_resources('mynet-0', dts, cloud_type)
+ r_info = yield from self.read_resource(dts,r_xpath)
+ networks.append((r_xpath, r_info.resource_info))
+
+ for i in range(2):
+ r_xpath = yield from self.reserve_compute_resources("mycompute-"+str(i),
+ dts,
+ cloud_type,
+ [networks[0][1].virtual_link_id])
+ r_info = yield from self.read_resource(dts,r_xpath)
+ computes.append((r_xpath, r_info))
+
+ yield from self.verify_resource_pools_config(dts)
+
+ for r in computes:
+ yield from self.release_compute_resources(dts, r[0])
+
+ yield from self.release_network_resources(dts,networks[0][0])
+ yield from self.verify_resource_pools_config(dts)
+
+ future = asyncio.ensure_future(run_test(), loop=self.loop)
+ self.run_until(future.done)
+ if future.exception() is not None:
+ self.log.error("Caught exception during test")
+ raise future.exception()
+
+ self.log.debug("DONE - test_static_pool_resource_allocation")
+
+ @unittest.skip("Skipping test_dynamic_pool_resource_allocation")
+ def test_dynamic_pool_resource_allocation(self):
+ self.log.debug("STARTING - test_dynamic_pool_resource_allocation")
+ tinfo = self.new_tinfo('dynamic_mock')
+ dts = rift.tasklets.DTS(tinfo, self.schema, self.loop)
+
+ @asyncio.coroutine
+ def run_test():
+ networks = []
+ computes = []
+ cloud_type = 'mock'
+ yield from self.wait_tasklets()
+ yield from self.configure_cloud_account(dts, cloud_type)
+ yield from self.configure_network_resource_pools(dts, "dynamic", cloud_type)
+ yield from self.configure_compute_resource_pools(dts, "dynamic", cloud_type)
+ yield from self.verify_resource_pools_config(dts)
+
+ r_xpath = yield from self.reserve_network_resources('mynet-0', dts, cloud_type)
+ r_info = yield from self.read_resource(dts,r_xpath)
+ networks.append((r_xpath, r_info.resource_info))
+
+ for i in range(2):
+ r_xpath = yield from self.reserve_compute_resources("mycompute-"+str(i),
+ dts,
+ cloud_type,
+ [networks[0][1].virtual_link_id])
+ r_info = yield from self.read_resource(dts,r_xpath)
+ computes.append((r_xpath, r_info))
+
+ yield from self.verify_resource_pools_config(dts)
+
+ for r in computes:
+ self.log.debug("Releasing compute resource with id: %s", r[1].resource_info.vdu_id)
+ yield from self.release_compute_resources(dts, r[0])
+
+ yield from self.release_network_resources(dts,networks[0][0])
+ yield from self.verify_resource_pools_config(dts)
+
+ future = asyncio.ensure_future(run_test(), loop=self.loop)
+ self.run_until(future.done)
+ if future.exception() is not None:
+ self.log.error("Caught exception during test")
+ raise future.exception()
+
+ self.log.debug("DONE - test_dynamic_pool_resource_allocation")
+
+ @unittest.skip("Skipping test_dynamic_pool_resource_allocation")
+ def test_dynamic_cloudsim_pool_resource_allocation(self):
+ self.log.debug("STARTING - test_dynamic_pool_resource_allocation")
+ tinfo = self.new_tinfo('dynamic_mock')
+ dts = rift.tasklets.DTS(tinfo, self.schema, self.loop)
+
+ @asyncio.coroutine
+ def run_test():
+ networks = []
+ computes = []
+ cloud_type = 'cloudsim'
+
+ yield from asyncio.sleep(120, loop=self.loop)
+ yield from self.configure_cloud_account(dts, cloud_type)
+ yield from self.configure_network_resource_pools(dts, "dynamic", cloud_type)
+ yield from self.configure_compute_resource_pools(dts, "dynamic", cloud_type)
+ yield from self.verify_resource_pools_config(dts)
+
+ r_xpath = yield from self.reserve_network_resources('mynet-0', dts, cloud_type)
+ r_info = yield from self.read_resource(dts,r_xpath)
+ networks.append((r_xpath, r_info.resource_info))
+
+ for i in range(2):
+ r_xpath = yield from self.reserve_compute_resources("mycompute-"+str(i),
+ dts,
+ cloud_type,
+ [networks[0][1].virtual_link_id])
+ r_info = yield from self.read_resource(dts,r_xpath)
+ computes.append((r_xpath, r_info))
+
+ yield from self.verify_resource_pools_config(dts)
+
+ for r in computes:
+ self.log.debug("Releasing compute resource with id: %s", r[1].resource_info.vdu_id)
+ yield from self.release_compute_resources(dts, r[0])
+
+ yield from self.release_network_resources(dts,networks[0][0])
+ yield from self.verify_resource_pools_config(dts)
+
+ future = asyncio.ensure_future(run_test(), loop=self.loop)
+ self.run_until(future.done)
+ if future.exception() is not None:
+ self.log.error("Caught exception during test")
+ raise future.exception()
+
+ self.log.debug("DONE - test_dynamic_pool_resource_allocation")
+
+ @unittest.skip("Skipping test_static_pool_openstack_resource_allocation")
+ def test_static_pool_openstack_resource_allocation(self):
+ self.log.debug("STARTING - test_static_pool_openstack_resource_allocation")
+ tinfo = self.new_tinfo('static_openstack')
+ dts = rift.tasklets.DTS(tinfo, self.schema, self.loop)
+
+ @asyncio.coroutine
+ def run_test():
+ networks = []
+ computes = []
+ cloud_type = 'openstack_static'
+ yield from self.wait_tasklets()
+ yield from self.configure_cloud_account(dts, cloud_type)
+ yield from self.configure_network_resource_pools(dts, "static", cloud_type)
+ yield from self.configure_compute_resource_pools(dts, "static", cloud_type)
+ yield from self.verify_resource_pools_config(dts)
+
+ self.log.debug("Creating virtual-network-resources in openstack")
+ r_xpath = yield from self.reserve_network_resources('mynet-0', dts, cloud_type)
+ r_info = yield from self.read_resource(dts,r_xpath)
+ networks.append((r_xpath, r_info.resource_info))
+ self.log.debug("virtual-network-resources successfully created in openstack")
+
+ self.log.debug("Creating virtual-network-compute in openstack")
+ for i in range(2):
+ r_xpath = yield from self.reserve_compute_resources("mycompute-" + str(i),
+ dts,
+ cloud_type,
+ [networks[0][1].virtual_link_id])
+ r_info = yield from self.read_resource(dts,r_xpath)
+ computes.append((r_xpath, r_info))
+
+ yield from self.verify_resource_pools_config(dts)
+ for r in computes:
+ self.log.debug("Releasing compute resource with id: %s", r[1].resource_info.vdu_id)
+ yield from self.release_compute_resources(dts, r[0])
+
+ yield from self.release_network_resources(dts,networks[0][0])
+ yield from self.verify_resource_pools_config(dts)
+ self.log.debug("Openstack static resource allocation completed")
+
+ future = asyncio.ensure_future(run_test(), loop=self.loop)
+ self.run_until(future.done)
+ if future.exception() is not None:
+ self.log.error("Caught exception during test")
+ raise future.exception()
+
+ self.log.debug("DONE - test_static_pool_openstack_resource_allocation")
+
+ #@unittest.skip("Skipping test_dynamic_pool_openstack_resource_allocation")
+ def test_dynamic_pool_openstack_resource_allocation(self):
+ self.log.debug("STARTING - test_dynamic_pool_openstack_resource_allocation")
+ tinfo = self.new_tinfo('dynamic_openstack')
+ dts = rift.tasklets.DTS(tinfo, self.schema, self.loop)
+
+ @asyncio.coroutine
+ def run_test():
+ networks = []
+ computes = []
+ cloud_type = 'openstack_dynamic'
+ yield from self.wait_tasklets()
+ yield from self.configure_cloud_account(dts, cloud_type)
+ yield from self.configure_network_resource_pools(dts, "dynamic", cloud_type)
+ yield from self.configure_compute_resource_pools(dts, "dynamic", cloud_type)
+ yield from self.verify_resource_pools_config(dts)
+
+ self.log.debug("Creating virtual-network-resources in openstack")
+ r_xpath = yield from self.reserve_network_resources('mynet-0', dts, cloud_type)
+ r_info = yield from self.read_resource(dts,r_xpath)
+ networks.append((r_xpath, r_info.resource_info))
+ self.log.debug("virtual-network-resources successfully created in openstack")
+
+ self.log.debug("Creating virtual-network-compute in openstack")
+ for i in range(2):
+ r_xpath = yield from self.reserve_compute_resources("mycompute-" + str(i),
+ dts,
+ cloud_type,
+ [networks[0][1].virtual_link_id])
+ r_info = yield from self.read_resource(dts,r_xpath)
+ computes.append((r_xpath, r_info))
+
+ yield from self.verify_resource_pools_config(dts)
+ for r in computes:
+ self.log.debug("Releasing compute resource with id: %s", r[1].resource_info.vdu_id)
+ #yield from self.release_compute_resources(dts, r[0])
+
+ self.log.debug("Releasing network resource with id: %s", r[1].resource_info.vdu_id)
+ #yield from self.release_network_resources(dts,networks[0][0])
+ #yield from self.verify_resource_pools_config(dts)
+ self.log.debug("Openstack dynamic resource allocation completed")
+
+ future = asyncio.ensure_future(run_test(), loop=self.loop)
+ self.run_until(future.done)
+ if future.exception() is not None:
+ self.log.error("Caught exception during test")
+ raise future.exception()
+
+ self.log.debug("DONE - test_dynamic_pool_openstack_resource_allocation")
+
+
+def main():
+ plugin_dir = os.path.join(os.environ["RIFT_INSTALL"], "usr/lib/rift/plugins")
+
+ if 'MESSAGE_BROKER_DIR' not in os.environ:
+ os.environ['MESSAGE_BROKER_DIR'] = os.path.join(plugin_dir, 'rwmsgbroker-c')
+
+ if 'ROUTER_DIR' not in os.environ:
+ os.environ['ROUTER_DIR'] = os.path.join(plugin_dir, 'rwdtsrouter-c')
+
+ if 'RM_DIR' not in os.environ:
+ os.environ['RM_DIR'] = os.path.join(plugin_dir, 'rwresmgrtasklet')
+
+ if 'CAL_PROXY_DIR' not in os.environ:
+ os.environ['CAL_PROXY_DIR'] = os.path.join(plugin_dir, 'rwcalproxytasklet')
+
+ if 'CNTR_MGR_DIR' not in os.environ:
+ os.environ['CNTR_MGR_DIR'] = os.path.join(plugin_dir, 'rwcntmgrtasklet')
+
+ runner = xmlrunner.XMLTestRunner(output=os.environ["RIFT_MODULE_TEST"])
+ unittest.main(testRunner=runner)
+
+if __name__ == '__main__':
+ main()
+
projects / osm / SO.git / blobdiff