4 # Copyright 2016-2017 RIFT.IO Inc
6 # Licensed under the Apache License, Version 2.0 (the "License");
7 # you may not use this file except in compliance with the License.
8 # You may obtain a copy of the License at
10 # http://www.apache.org/licenses/LICENSE-2.0
12 # Unless required by applicable law or agreed to in writing, software
13 # distributed under the License is distributed on an "AS IS" BASIS,
14 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 # See the License for the specific language governing permissions and
16 # limitations under the License.
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')
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
55 if sys
.version_info
< (3, 4, 4):
56 asyncio
.ensure_future
= asyncio
.async
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']}
70 def create_mock_resource_temaplate():
71 ### Resource to be reuqested for 'mock'
72 resource_requests
= {'compute': {}, 'network': {}}
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
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
91 msg
= rmgryang
.VirtualLinkEventData_RequestInfo()
92 resource_requests
['network']['mynet-0'] = msg
95 msg
= rmgryang
.VirtualLinkEventData_RequestInfo()
96 resource_requests
['network']['mynet-1'] = msg
98 return resource_requests
101 def create_cloudsim_resource_template():
102 ### Resource to be reuqested for 'cloudsim'
103 resource_requests
= {'compute': {}, 'network': {}}
106 msg
= rmgryang
.VDUEventData_RequestInfo()
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
114 msg
= rmgryang
.VDUEventData_RequestInfo()
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
122 msg
= rmgryang
.VirtualLinkEventData_RequestInfo()
123 resource_requests
['network']['mynet-0'] = msg
126 msg
= rmgryang
.VirtualLinkEventData_RequestInfo()
127 resource_requests
['network']['mynet-1'] = msg
129 return resource_requests
131 def create_mock_resource_temaplate():
132 ### Resource to be reuqested for 'mock'
133 resource_requests
= {'compute': {}, 'network': {}}
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
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
152 msg
= rmgryang
.VirtualLinkEventData_RequestInfo()
153 resource_requests
['network']['mynet-0'] = msg
156 msg
= rmgryang
.VirtualLinkEventData_RequestInfo()
157 resource_requests
['network']['mynet-1'] = msg
159 return resource_requests
162 def create_openstack_static_template():
163 ### Resource to be reuqested for 'openstack_static'
164 resource_requests
= {'compute': {}, 'network': {}}
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
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
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
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
196 return resource_requests
199 def create_openstack_dynamic_template():
200 ### Resource to be reuqested for 'openstack_dynamic'
201 resource_requests
= {'compute': {}, 'network': {}}
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
213 resource_requests
['compute']['mycompute-0'] = msg
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
225 resource_requests
['compute']['mycompute-1'] = msg
228 msg
= rmgryang
.VirtualLinkEventData_RequestInfo()
229 #msg.provider_network.overlay_type = 'VXLAN'
230 #msg.provider_network.segmentation_id = 71
232 resource_requests
['network']['mynet-0'] = msg
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
240 return resource_requests
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(),
253 def get_cal_account(account_type
):
255 Creates an object for class RwcalYang.CloudAccount()
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']
271 elif account_type
== 'cloudsim':
272 account
.name
= 'cloudsim'
273 account
.account_type
= "cloudsim_proxy"
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")
283 rc
= rwcal
.init(log_hdl
)
284 assert rc
== RwStatus
.SUCCESS
285 except Exception as e
:
290 class RMMgrTestCase(rift
.test
.dts
.AbstractDTSTest
):
292 rwcal_acct_info
= None
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')
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')
305 def configure_schema(cls
):
306 return rmgryang
.get_schema()
309 def wait_tasklets(self
):
310 yield from asyncio
.sleep(1, loop
=self
.loop
)
313 def configure_timeout(cls
):
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
323 def get_compute_pool_msg(self
, name
, pool_type
, cloud_type
):
324 pool_config
= rmgryang
.ResourcePools()
325 pool
= pool_config
.pools
.add()
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
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
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
348 pool
.pool_type
= 'dynamic'
352 def get_network_pool_msg(self
, name
, pool_type
, cloud_type
):
353 pool_config
= rmgryang
.ResourcePools()
354 pool
= pool_config
.pools
.add()
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
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
376 pool
.pool_type
= 'dynamic'
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']
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
))
394 return msg
, xpath
.format(event_id
)
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']
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
,
409 getattr(resource_requests
[cloud_type
]['compute'][name
].vm_flavor
, attr
))
411 attributes
= ['mempage_size', 'cpu_pinning_policy']
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
,
418 getattr(resource_requests
[cloud_type
]['compute'][name
].guest_epa
, attr
))
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
425 c1
= msg
.request_info
.connection_points
.add()
426 c1
.name
= name
+"-port-"+str(cnt
)
428 c1
.virtual_link_id
= link
430 self
.log
.info("Sending message :%s", msg
)
431 return msg
, xpath
.format(event_id
)
434 def configure_cloud_account(self
, dts
, acct_type
):
435 account_xpath
= "C,/rw-project:project/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
,
443 def configure_compute_resource_pools(self
, dts
, resource_type
, cloud_type
):
444 pool_xpath
= "C,/rw-project:project/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
,
453 def configure_network_resource_pools(self
, dts
, resource_type
, cloud_type
):
454 pool_xpath
= "C,/rw-project:project/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
,
462 def verify_resource_pools_config(self
, dts
):
463 pool_records_xpath
= "D,/rw-project:project/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",
476 record
.resource_type
,
478 record
.total_resources
,
479 record
.allocated_resources
,
480 record
.free_resources
)
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
)
489 self
.log
.debug("Received data: %s", msg
.result
)
493 def reserve_network_resources(self
, name
, dts
, cloud_type
):
494 network_xpath
= "D,/rw-project:project/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
)
502 def reserve_compute_resources(self
, name
, dts
, cloud_type
, vlinks
= []):
503 compute_xpath
= "D,/rw-project:project/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
)
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)
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)
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
)
530 yield from self
.wait_tasklets()
531 yield from self
.configure_cloud_account(dts
, cloud_type
)
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
)
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
))
542 r_xpath
= yield from self
.reserve_compute_resources("mycompute-"+str(i
),
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
))
549 yield from self
.verify_resource_pools_config(dts
)
552 yield from self
.release_compute_resources(dts
, r
[0])
554 yield from self
.release_network_resources(dts
,networks
[0][0])
555 yield from self
.verify_resource_pools_config(dts
)
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()
563 self
.log
.debug("DONE - test_static_pool_resource_allocation")
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
)
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
)
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
))
587 r_xpath
= yield from self
.reserve_compute_resources("mycompute-"+str(i
),
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
))
594 yield from self
.verify_resource_pools_config(dts
)
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])
600 yield from self
.release_network_resources(dts
,networks
[0][0])
601 yield from self
.verify_resource_pools_config(dts
)
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()
609 self
.log
.debug("DONE - test_dynamic_pool_resource_allocation")
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
)
621 cloud_type
= 'cloudsim'
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
)
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
))
634 r_xpath
= yield from self
.reserve_compute_resources("mycompute-"+str(i
),
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
))
641 yield from self
.verify_resource_pools_config(dts
)
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])
647 yield from self
.release_network_resources(dts
,networks
[0][0])
648 yield from self
.verify_resource_pools_config(dts
)
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()
656 self
.log
.debug("DONE - test_dynamic_pool_resource_allocation")
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
)
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
)
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")
681 self
.log
.debug("Creating virtual-network-compute in openstack")
683 r_xpath
= yield from self
.reserve_compute_resources("mycompute-" + str(i
),
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
))
690 yield from self
.verify_resource_pools_config(dts
)
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])
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")
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()
705 self
.log
.debug("DONE - test_static_pool_openstack_resource_allocation")
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
)
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
)
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")
730 self
.log
.debug("Creating virtual-network-compute in openstack")
732 r_xpath
= yield from self
.reserve_compute_resources("mycompute-" + str(i
),
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
))
739 yield from self
.verify_resource_pools_config(dts
)
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])
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")
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()
755 self
.log
.debug("DONE - test_dynamic_pool_openstack_resource_allocation")
759 plugin_dir
= os
.path
.join(os
.environ
["RIFT_INSTALL"], "usr/lib/rift/plugins")
761 if 'MESSAGE_BROKER_DIR' not in os
.environ
:
762 os
.environ
['MESSAGE_BROKER_DIR'] = os
.path
.join(plugin_dir
, 'rwmsgbroker-c')
764 if 'ROUTER_DIR' not in os
.environ
:
765 os
.environ
['ROUTER_DIR'] = os
.path
.join(plugin_dir
, 'rwdtsrouter-c')
767 if 'RM_DIR' not in os
.environ
:
768 os
.environ
['RM_DIR'] = os
.path
.join(plugin_dir
, 'rwresmgrtasklet')
770 if 'CAL_PROXY_DIR' not in os
.environ
:
771 os
.environ
['CAL_PROXY_DIR'] = os
.path
.join(plugin_dir
, 'rwcalproxytasklet')
773 if 'CNTR_MGR_DIR' not in os
.environ
:
774 os
.environ
['CNTR_MGR_DIR'] = os
.path
.join(plugin_dir
, 'rwcntmgrtasklet')
776 runner
= xmlrunner
.XMLTestRunner(output
=os
.environ
["RIFT_MODULE_TEST"])
777 unittest
.main(testRunner
=runner
)
779 if __name__
== '__main__':