3 # Copyright 2016 RIFT.IO Inc
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at
9 # http://www.apache.org/licenses/LICENSE-2.0
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
23 import novaclient
.exceptions
as nova_exception
27 from keystoneclient
import v3
as ksclient
29 from gi
.repository
import RwcalYang
30 from gi
.repository
.RwTypes
import RwStatus
31 #from rift.rwcal.openstack.openstack_drv import KeystoneDriver, NovaDriver, KeystoneDriverV3, KeystoneDriverV2
33 logger
= logging
.getLogger('rwcal-openstack')
38 chpasswd: { expire: False }
43 # Important information about openstack installation. This needs to be manually verified
46 'username' : 'xxxxxx',
48 'auth_url' : 'http://10.66.4.102:5000/v2.0/',
49 'project_name' : 'xxxxx',
50 'mgmt_network' : 'private',
51 'reserved_flavor' : 'm1.medium',
52 'reserved_image' : 'Fedora-x86_64-20-20131211.1-sda-ping.qcow2',
53 'physical_network' : None,
54 'network_type' : None,
55 'segmentation_id' : None,
56 'user_domain_name' : 'default',
57 'project_domain_name': 'default'
61 'username' : 'riftdev_admin',
62 'password' : 'mypasswd',
63 'auth_url' : 'http://10.68.0.11:5000/v3/',
64 'project_name' : 'demov3',
65 'mgmt_network' : 'center',
66 'physical_network' : None,
67 'network_type' : None,
68 'segmentation_id' : None,
69 'user_domain_name' : 'riftdev',
70 'project_domain_name': 'riftdev'
74 def get_cal_account():
76 Creates an object for class RwcalYang.YangData_RwProject_Project_CloudAccounts_CloudAccountList()
78 account
= RwcalYang
.YangData_RwProject_Project_CloudAccounts_CloudAccountList()
79 account
.name
= "Gruntxx"
80 account
.account_type
= "openstack"
81 account
.openstack
.key
= openstack_info
['username']
82 account
.openstack
.secret
= openstack_info
['password']
83 account
.openstack
.auth_url
= openstack_info
['auth_url']
84 account
.openstack
.tenant
= openstack_info
['project_name']
85 account
.openstack
.mgmt_network
= openstack_info
['mgmt_network']
86 account
.openstack
.user_domain
= openstack_info
['user_domain_name']
87 account
.openstack
.project_domain
= openstack_info
['project_domain_name']
92 Loads rw.cal plugin via libpeas
94 plugin
= rw_peas
.PeasPlugin('rwcal_openstack', 'RwCal-1.0')
95 engine
, info
, extension
= plugin()
97 # Get the RwLogger context
98 rwloggerctx
= rwlogger
.RwLog
.Ctx
.new("Cal-Log")
100 cal
= plugin
.get_interface("Cloud")
102 rc
= cal
.init(rwloggerctx
)
103 assert rc
== RwStatus
.SUCCESS
105 logger
.error("ERROR:Cal plugin instantiation failed. Aborting tests")
107 logger
.info("Openstack Cal plugin successfully instantiated")
111 class OpenStackTest(unittest
.TestCase
):
112 NodeID
= "123456789012345" # Some random number to test VM tagging
113 MemoryPageSize
= "LARGE"
114 CpuPolicy
= "DEDICATED"
115 CpuThreadPolicy
= "SEPARATE"
118 HostTrust
= "trusted"
119 PCIPassThroughAlias
= "PCI_10G_ALIAS"
120 SEG_ID
= openstack_info
['segmentation_id']
125 - It is assumed that openstack install has a flavor and image precreated.
126 - Flavor_name: x1.xlarge
127 - Image_name : rwimage
129 If these resources are not then this test will fail.
131 self
._acct
= get_cal_account()
132 logger
.info("Openstack-CAL-Test: setUp")
133 self
.cal
= get_cal_plugin()
134 logger
.info("Openstack-CAL-Test: setUpEND")
136 # First check for VM Flavor and Image and get the corresponding IDs
137 rc
, rs
= self
.cal
.get_flavor_list(self
._acct
)
138 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
140 flavor_list
= [ flavor
for flavor
in rs
.flavorinfo_list
if flavor
.name
== openstack_info
['reserved_flavor'] ]
141 self
.assertNotEqual(len(flavor_list
), 0)
142 self
._flavor
= flavor_list
[0]
144 rc
, rs
= self
.cal
.get_image_list(self
._acct
)
145 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
147 image_list
= [ image
for image
in rs
.imageinfo_list
if image
.name
== openstack_info
['reserved_image'] ]
148 self
.assertNotEqual(len(image_list
), 0)
149 self
._image
= image_list
[0]
151 rc
, rs
= self
.cal
.get_network_list(self
._acct
)
152 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
153 networks
= [ network
for network
in rs
.networkinfo_list
if ((network
.network_name
== 'rift.cal.unittest.network') or ('rift.cal.virtual_link' in network
.network_name
) ) ]
154 for network
in networks
:
155 logger
.debug("Openstack-CAL-Test: Deleting old VL %s", network
.network_id
)
156 self
.cal
.delete_virtual_link(self
._acct
, network
.network_id
)
159 logger
.info("Openstack-CAL-Test: tearDown")
162 def _md5(fname
, blksize
=1048576):
163 hash_md5
= hashlib
.md5()
164 with
open(fname
, "rb") as f
:
165 for chunk
in iter(lambda: f
.read(blksize
), b
""):
166 hash_md5
.update(chunk
)
167 return hash_md5
.hexdigest()
169 @unittest.skip("Skipping test_list_flavors")
170 def test_list_flavor(self
):
172 List existing flavors from openstack installation
174 logger
.info("Openstack-CAL-Test: Starting List Flavors Test")
175 rc
, rsp
= self
.cal
.get_flavor_list(self
._acct
)
176 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
177 logger
.info("Openstack-CAL-Test: Received %d flavors" %(len(rsp
.flavorinfo_list
)))
178 for flavor
in rsp
.flavorinfo_list
:
179 rc
, flv
= self
.cal
.get_flavor(self
._acct
, flavor
.id)
180 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
181 self
.assertEqual(flavor
.id, flv
.id)
183 @unittest.skip("Skipping test_list_images")
184 def test_list_images(self
):
186 List existing images from openstack installation
188 logger
.info("Openstack-CAL-Test: Starting List Images Test")
189 rc
, rsp
= self
.cal
.get_image_list(self
._acct
)
190 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
191 logger
.info("Openstack-CAL-Test: Received %d images" %(len(rsp
.imageinfo_list
)))
192 #for image in rsp.imageinfo_list:
193 # rc, img = self.cal.get_image(self._acct, image.id)
194 # self.assertEqual(rc, RwStatus.SUCCESS)
195 # self.assertEqual(image.id, img.id)
197 @unittest.skip("Skipping test_list_vms")
198 def test_list_vms(self
):
200 List existing VMs from openstack installation
202 logger
.info("Openstack-CAL-Test: Starting List VMs Test")
203 rc
, rsp
= self
.cal
.get_vm_list(self
._acct
)
204 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
205 logger
.info("Openstack-CAL-Test: Received %d VMs" %(len(rsp
.vminfo_list
)))
206 for vm
in rsp
.vminfo_list
:
207 rc
, server
= self
.cal
.get_vm(self
._acct
, vm
.vm_id
)
208 self
.assertEqual(vm
.vm_id
, server
.vm_id
)
210 @unittest.skip("Skipping test_list_networks")
211 def test_list_networks(self
):
213 List existing Network from openstack installation
215 logger
.info("Openstack-CAL-Test: Starting List Networks Test")
216 rc
, rsp
= self
.cal
.get_network_list(self
._acct
)
217 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
218 logger
.info("Openstack-CAL-Test: Received %d Networks" %(len(rsp
.networkinfo_list
)))
219 for network
in rsp
.networkinfo_list
:
220 rc
, net
= self
.cal
.get_network(self
._acct
, network
.network_id
)
221 self
.assertEqual(network
.network_id
, net
.network_id
)
223 @unittest.skip("Skipping test_list_ports")
224 def test_list_ports(self
):
226 List existing Ports from openstack installation
228 logger
.info("Openstack-CAL-Test: Starting List Ports Test")
229 rc
, rsp
= self
.cal
.get_port_list(self
._acct
)
230 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
231 assert(rc
== RwStatus
.SUCCESS
)
232 logger
.info("Openstack-CAL-Test: Received %d Ports" %(len(rsp
.portinfo_list
)))
233 for port
in rsp
.portinfo_list
:
234 rc
, p
= self
.cal
.get_port(self
._acct
, port
.port_id
)
235 self
.assertEqual(port
.port_id
, p
.port_id
)
237 def _get_image_info_request(self
):
239 Returns request object of type RwcalYang.YangData_RwProject_Project_VimResources_ImageinfoList()
241 img
= RwcalYang
.YangData_RwProject_Project_VimResources_ImageinfoList()
242 img
.name
= "rift.cal.unittest.image"
243 img
.location
= '/net/sharedfiles/home1/common/vm/rift-root-latest.qcow2'
244 img
.disk_format
= "qcow2"
245 img
.container_format
= "bare"
246 img
.checksum
= self
._md
5(img
.location
)
249 def _get_image_info(self
, img_id
):
251 Checks the image status until it becomes active or timeout occurs (100sec)
252 Returns the image_info dictionary
257 rc
, rs
= self
.cal
.get_image(self
._acct
, img_id
)
258 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
259 logger
.info("Openstack-CAL-Test: Image (image_id: %s) reached state : %s" %(img_id
, rs
.state
))
260 if rs
.state
== 'active':
263 time
.sleep(2) # Sleep for a second
266 @unittest.skip("Skipping test_create_delete_image")
267 def test_create_delete_image(self
):
269 Create/Query/Delete a new image in openstack installation
271 logger
.info("Openstack-CAL-Test: Starting Image create test")
272 img
= self
._get
_image
_info
_request
()
273 rc
, img_id
= self
.cal
.create_image(self
._acct
, img
)
274 logger
.info("Openstack-CAL-Test: Created Image with image_id: %s" %(img_id))
275 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
276 img_info
= self
._get
_image
_info
(img_id
)
277 self
.assertNotEqual(img_info
, None)
278 self
.assertEqual(img_id
, img_info
.id)
279 logger
.info("Openstack-CAL-Test: Image (image_id: %s) reached state : %s" %(img_id
, img_info
.state
))
280 self
.assertEqual(img_info
.has_field('checksum'), True)
281 #self.assertEqual(img_info.checksum, OpenStackTest.IMG_Checksum)
282 logger
.info("Openstack-CAL-Test: Initiating Delete Image operation for image_id: %s" %(img_id))
283 rc
= self
.cal
.delete_image(self
._acct
, img_id
)
284 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
285 logger
.info("Openstack-CAL-Test: Image (image_id: %s) successfully deleted" %(img_id))
287 def _get_flavor_info_request(self
):
289 Returns request object of type RwcalYang.YangData_RwProject_Project_VimResources_FlavorinfoList()
291 flavor
= RwcalYang
.YangData_RwProject_Project_VimResources_FlavorinfoList()
292 flavor
.name
= 'rift.cal.unittest.flavor'
293 flavor
.vm_flavor
.memory_mb
= 16384 # 16GB
294 flavor
.vm_flavor
.vcpu_count
= 4
295 flavor
.vm_flavor
.storage_gb
= 40 # 40GB
296 flavor
.guest_epa
.mempage_size
= OpenStackTest
.MemoryPageSize
297 flavor
.guest_epa
.cpu_pinning_policy
= OpenStackTest
.CpuPolicy
298 flavor
.guest_epa
.cpu_thread_pinning_policy
= OpenStackTest
.CpuThreadPolicy
299 flavor
.guest_epa
.numa_node_policy
.node_cnt
= OpenStackTest
.NumaNodeCount
300 for i
in range(OpenStackTest
.NumaNodeCount
):
301 node
= flavor
.guest_epa
.numa_node_policy
.node
.add()
304 vcpu
= node
.vcpu
.add()
306 vcpu
= node
.vcpu
.add()
309 vcpu
= node
.vcpu
.add()
311 vcpu
= node
.vcpu
.add()
313 node
.memory_mb
= 8196
314 dev
= flavor
.guest_epa
.pcie_device
.add()
315 dev
.device_id
= OpenStackTest
.PCIPassThroughAlias
319 @unittest.skip("Skipping test_create_delete_flavor")
320 def test_create_delete_flavor(self
):
322 Create/Query/Delete a new flavor in openstack installation
324 logger
.info("Openstack-CAL-Test: Starting Image create/delete test")
326 ### Delete any previously created flavor with name rift.cal.unittest.flavor
327 rc
, rs
= self
.cal
.get_flavor_list(self
._acct
)
328 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
329 flavor_list
= [ flavor
for flavor
in rs
.flavorinfo_list
if flavor
.name
== 'rift.cal.unittest.flavor' ]
331 rc
= self
.cal
.delete_flavor(self
._acct
, flavor_list
[0].id)
332 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
334 flavor
= self
._get
_flavor
_info
_request
()
335 rc
, flavor_id
= self
.cal
.create_flavor(self
._acct
, flavor
)
336 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
338 logger
.info("Openstack-CAL-Test: Created new flavor with flavor_id : %s" %(flavor_id))
339 rc
, rs
= self
.cal
.get_flavor(self
._acct
, flavor_id
)
340 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
341 self
.assertEqual(rs
.id, flavor_id
)
343 # Verify EPA Attributes
344 self
.assertEqual(rs
.guest_epa
.mempage_size
, OpenStackTest
.MemoryPageSize
)
345 self
.assertEqual(rs
.guest_epa
.cpu_pinning_policy
, OpenStackTest
.CpuPolicy
)
346 self
.assertEqual(rs
.guest_epa
.cpu_thread_pinning_policy
, OpenStackTest
.CpuThreadPolicy
)
347 self
.assertEqual(rs
.guest_epa
.numa_node_policy
.node_cnt
, OpenStackTest
.NumaNodeCount
)
348 self
.assertEqual(len(rs
.guest_epa
.pcie_device
), 1)
349 self
.assertEqual(rs
.guest_epa
.pcie_device
[0].device_id
, OpenStackTest
.PCIPassThroughAlias
)
350 self
.assertEqual(rs
.guest_epa
.pcie_device
[0].count
, 1)
351 logger
.info("Openstack-CAL-Test: Initiating delete for flavor_id : %s" %(flavor_id))
352 rc
= self
.cal
.delete_flavor(self
._acct
, flavor_id
)
353 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
354 # Check that flavor does not exist anymore in list_flavor
355 rc
, rs
= self
.cal
.get_flavor_list(self
._acct
)
356 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
357 flavor_list
= [ flavor
for flavor
in rs
.flavorinfo_list
if flavor
.id == flavor_id
]
358 # Flavor List should be empty
359 self
.assertEqual(len(flavor_list
), 0)
360 logger
.info("Openstack-CAL-Test: Flavor (flavor_id: %s) successfully deleted" %(flavor_id))
362 def _get_vm_info_request(self
, flavor_id
, image_id
):
364 Returns request object of type RwcalYang.VMInfoItem
366 vm
= RwcalYang
.YangData_RwProject_Project_VimResources_VminfoList()
367 vm
.vm_name
= 'rift.cal.unittest.vm'
368 vm
.flavor_id
= flavor_id
369 vm
.image_id
= image_id
370 vm
.cloud_init
.userdata
= ''
371 vm
.user_tags
.node_id
= OpenStackTest
.NodeID
374 def _check_vm_state(self
, vm_id
, expected_state
):
376 Wait until VM reaches particular state (expected_state).
378 # Wait while VM goes to required state
380 for i
in range(50): # 50 poll iterations...
381 rc
, rs
= self
.cal
.get_vm(self
._acct
, vm_id
)
382 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
383 logger
.info("Openstack-CAL-Test: VM vm_id : %s. Current VM state : %s " %(vm_id
, rs
.state
))
384 if rs
.state
== expected_state
:
389 rc
, rs
= self
.cal
.get_vm(self
._acct
, vm_id
)
390 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
391 self
.assertEqual(rs
.state
, expected_state
)
393 def _create_vm(self
, flavor
, image
, port_list
= None):
395 Create VM and perform validity checks
397 logger
.info("Openstack-CAL-Test: Using image : %s and flavor : %s " %(image
.name
, flavor
.name
))
398 vm
= self
._get
_vm
_info
_request
(flavor
.id, image
.id)
401 for port_id
in port_list
:
402 port
= vm
.port_list
.add()
403 port
.port_id
= port_id
405 rc
, vm_id
= self
.cal
.create_vm(self
._acct
, vm
)
406 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
408 ### Check if VM creation is successful
409 rc
, rs
= self
.cal
.get_vm(self
._acct
, vm_id
)
410 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
411 logger
.info("Openstack-CAL-Test: Successfully created VM with vm_id : %s. Current VM state : %s " %(vm_id
, rs
.state
))
413 ### Ensure the VM state is active
414 self
._check
_vm
_state
(vm_id
, 'ACTIVE')
416 ### Ensure that userdata tags are set as expected
417 rc
, rs
= self
.cal
.get_vm(self
._acct
, vm_id
)
418 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
419 self
.assertEqual(rs
.user_tags
.has_field('node_id'), True)
420 self
.assertEqual(getattr(rs
.user_tags
, 'node_id'), OpenStackTest
.NodeID
)
421 logger
.info("Openstack-CAL-Test: Successfully verified the user tags for VM-ID: %s" %(vm_id))
424 def _delete_vm(self
, vm_id
):
426 Delete VM and perform validity checks
428 rc
, rs
= self
.cal
.get_vm(self
._acct
, vm_id
)
429 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
431 logger
.info("Openstack-CAL-Test: Initiating VM Delete operation on VM vm_id : %s. Current VM state : %s " %(vm_id
, rs
.state
))
433 rc
= self
.cal
.delete_vm(self
._acct
, vm_id
)
434 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
437 # Check if VM still exists
438 rc
, rs
= self
.cal
.get_vm_list(self
._acct
)
439 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
440 vm_list
= [vm
for vm
in rs
.vminfo_list
if vm
.vm_id
== vm_id
]
444 rc
, rs
= self
.cal
.get_vm_list(self
._acct
)
445 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
446 vm_list
= [vm
for vm
in rs
.vminfo_list
if vm
.vm_id
== vm_id
]
447 self
.assertEqual(len(vm_list
), 0)
448 logger
.info("Openstack-CAL-Test: VM with vm_id : %s successfully deleted" %(vm_id))
450 def _stop_vm(self
, vm_id
):
452 Stop VM and perform validity checks
454 rc
, rs
= self
.cal
.get_vm(self
._acct
, vm_id
)
455 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
456 logger
.info("Openstack-CAL-Test: Initiating Stop VM operation on VM vm_id : %s. Current VM state : %s " %(vm_id
, rs
.state
))
457 rc
= self
.cal
.stop_vm(self
._acct
, vm_id
)
458 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
459 ### Ensure that VM state is SHUTOFF
460 self
._check
_vm
_state
(vm_id
, 'SHUTOFF')
463 def _start_vm(self
, vm_id
):
465 Starts VM and performs validity checks
467 rc
, rs
= self
.cal
.get_vm(self
._acct
, vm_id
)
468 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
469 logger
.info("Openstack-CAL-Test: Initiating Start VM operation on VM vm_id : %s. Current VM state : %s " %(vm_id
, rs
.state
))
470 rc
= self
.cal
.start_vm(self
._acct
, vm_id
)
471 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
473 ### Ensure that VM state is ACTIVE
474 self
._check
_vm
_state
(vm_id
, 'ACTIVE')
477 def _reboot_vm(self
, vm_id
):
479 Reboot VM and perform validity checks
481 rc
, rs
= self
.cal
.get_vm(self
._acct
, vm_id
)
482 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
483 logger
.info("Openstack-CAL-Test: Initiating Reboot VM operation on VM vm_id : %s. Current VM state : %s " %(vm_id
, rs
.state
))
484 rc
= self
.cal
.reboot_vm(self
._acct
, vm_id
)
485 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
487 ### Ensure that VM state is ACTIVE
488 self
._check
_vm
_state
(vm_id
, 'ACTIVE')
490 def assert_vm(self
, vm_data
, flavor
):
491 """Verify the newly created VM for attributes specified in the flavor.
494 vm_data (VmData): Instance of the newly created VM
495 flavor (FlavorInfoItem): Config flavor.
499 # Page size seems to be 4096, regardless of the page size name.
500 page_lookup
= {"large": '4096', "small": '4096'}
501 FIELDS
= ["vcpus", "cpu_threads", "memory_page_size", "disk",
502 "numa_node_count", "memory", "pci_passthrough_device_list"]
505 if field
not in vm_config
:
508 vm_value
= getattr(vm_data
, field
)
509 config_value
= getattr(vm_config
, field
)
511 if field
== "memory_page_size":
512 config_value
= page_lookup
[config_value
]
514 if field
== "memory":
515 config_value
= int(config_value
/1000)
517 if field
== "pci_passthrough_device_list":
518 config_value
= len(config_value
)
519 vm_value
= len(vm_value
)
521 self
.assertEqual(vm_value
, config_value
)
523 @unittest.skip("Skipping test_vm_epa_attributes")
524 def test_vm_epa_attributes(self
):
526 Primary goal: To create a VM with the specified EPA Attributes
527 Secondary goal: To verify flavor creation/delete
530 logger
.info("Openstack-CAL-Test: Starting VM(EPA) create/delete test")
531 flavor
= self
._get
_flavor
_info
_request
()
533 rc
, flavor_id
= self
.cal
.do_create_flavor(self
._acct
, flavor
)
534 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
535 flavor
.id = flavor_id
537 data
, vm_id
= self
._create
_vm
(flavor
, self
._image
)
539 vm_data
= VmData(data
.host_name
, data
.management_ip
)
540 self
.assert_vm(vm_data
, flavor
)
542 self
._delete
_vm
(vm_id
)
544 rc
= self
.cal
.do_delete_flavor(self
._acct
, flavor_id
)
545 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
548 @unittest.skip("Skipping test_expiry_token")
549 def test_expiry_token(self):
551 Primary goal: To verify if we are refreshing the expired tokens.
553 logger.info("Openstack-CAL-Test: Starting token refresh test")
554 drv = KeystoneDriver(
555 openstack_info['username'],
556 openstack_info['password'],
557 openstack_info['auth_url'],
559 openstack_info['project_name'])
560 # Get hold of the client instance need for Token Manager
561 client = drv._get_keystone_connection()
563 auth_ref = client.auth_ref
564 token = auth_ref['auth_token']
566 # Verify if the newly acquired token works.
567 nova = NovaDriver(drv)
568 flavors = nova.flavor_list()
569 self.assertTrue(len(flavors) > 1)
571 # Invalidate the token
572 token_manger = ksclient.tokens.TokenManager(client)
573 token_manger.revoke_token(token)
579 flavors = nova.flavor_list()
581 except nova_exception.AuthorizationFailure:
584 self.assertTrue(unauth_exp)
586 # Explicitly reset the expire time, to test if we acquire a new token
587 now = datetime.datetime.utcnow()
588 time_str = format(now, "%Y-%m-%dT%H:%M:%S.%fZ")
589 drv._get_keystone_connection().auth_ref['expires_at'] = time_str
591 flavors = nova.flavor_list()
592 self.assertTrue(len(flavors) > 1)
594 def test_v3_Keystone(self):
595 # Keystone v3 authentication
598 drv = KeystoneDriverV3(openstack_V3_info['username'],
599 openstack_V3_info['password'],
600 openstack_V3_info['auth_url'],
601 openstack_V3_info['project_name'],
603 openstack_V3_info['user_domain_name'],
604 openstack_V3_info['project_domain_name'])
605 client = drv._get_keystone_connection()
608 self.assertFalse(auth_exp)
610 # Incorrect domain being to passed to v3 Keystone API
613 drv = KeystoneDriverV3(openstack_V3_info['username'],
614 openstack_V3_info['password'],
615 openstack_V3_info['auth_url'],
616 openstack_V3_info['project_name'],
619 openstack_V3_info['project_domain_name'])
620 client = drv._get_keystone_connection()
623 self.assertTrue(auth_exp)
625 # Keystone v3 authentication-Backward compatabilty test
628 drv = KeystoneDriverV3(openstack_info['username'],
629 openstack_info['password'],
630 openstack_info['auth_url'],
631 openstack_info['project_name'],
633 openstack_info['user_domain_name'],
634 openstack_info['project_domain_name'])
635 client = drv._get_keystone_connection()
638 self.assertFalse(auth_exp)
640 # Keystone v3 authentication-Backward compatabilty
643 drv = KeystoneDriverV3(openstack_info['username'],
644 openstack_info['password'],
645 openstack_info['auth_url'],
646 openstack_info['project_name'],
650 client = drv._get_keystone_connection()
653 self.assertFalse(auth_exp)
655 # Keystone v2 authentication
658 drv2 = KeystoneDriverV2(
659 openstack_info['username'],
660 openstack_info['password'],
661 'http://10.66.4.17:5000/v2.0',
662 openstack_info['project_name'],
664 client = drv2._get_keystone_connection()
667 self.assertFalse(auth_exp)
670 @unittest.skip("Skipping test_vm_operations")
671 def test_vm_operations(self
):
673 Primary goal: Create/Query/Delete VM in openstack installation.
674 Secondary goal: VM pause/resume operations on VM.
677 logger
.info("Openstack-CAL-Test: Starting VM Operations test")
680 data
, vm_id
= self
._create
_vm
(self
._flavor
, self
._image
)
685 self
._start
_vm
(vm_id
)
687 vm_data
= VmData(data
.host_name
, data
.management_ip
)
688 self
.assert_vm(vm_data
, self
._flavor
)
691 self
._reboot
_vm
(vm_id
)
693 self
._delete
_vm
(vm_id
)
696 def _get_network_info_request(self
):
698 Returns request object of type RwcalYang.YangData_RwProject_Project_VimResources_NetworkinfoList
700 network
= RwcalYang
.YangData_RwProject_Project_VimResources_NetworkinfoList()
701 network
.network_name
= 'rift.cal.unittest.network'
702 network
.subnet
= '192.168.16.0/24'
703 if openstack_info
['physical_network']:
704 network
.provider_network
.physical_network
= openstack_info
['physical_network']
705 if openstack_info
['network_type']:
706 network
.provider_network
.overlay_type
= openstack_info
['network_type']
707 if OpenStackTest
.SEG_ID
:
708 network
.provider_network
.segmentation_id
= OpenStackTest
.SEG_ID
709 OpenStackTest
.SEG_ID
+= 1
713 def _create_network(self
):
715 Create a network and verify that network creation is successful
717 network
= self
._get
_network
_info
_request
()
720 logger
.info("Openstack-CAL-Test: Creating a network with name : %s" %(network
.network_name
))
721 rc
, net_id
= self
.cal
.create_network(self
._acct
, network
)
722 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
724 ### Verify network is created successfully
725 rc
, rs
= self
.cal
.get_network(self
._acct
, net_id
)
726 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
727 logger
.info("Openstack-CAL-Test: Successfully create Network : %s with id : %s." %(network
.network_name
, net_id
))
731 def _delete_network(self
, net_id
):
733 Delete network and verify that delete operation is successful
735 rc
, rs
= self
.cal
.get_network(self
._acct
, net_id
)
736 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
738 logger
.info("Openstack-CAL-Test: Deleting a network with id : %s. " %(net_id))
739 rc
= self
.cal
.delete_network(self
._acct
, net_id
)
740 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
742 # Verify that network is no longer available via get_network_list API
743 rc
, rs
= self
.cal
.get_network_list(self
._acct
)
744 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
745 network_info
= [ network
for network
in rs
.networkinfo_list
if network
.network_id
== net_id
]
746 self
.assertEqual(len(network_info
), 0)
747 logger
.info("Openstack-CAL-Test: Successfully deleted Network with id : %s" %(net_id))
750 @unittest.skip("Skipping test_network_operations")
751 def test_network_operations(self
):
753 Create/Delete Networks
755 logger
.info("Openstack-CAL-Test: Starting Network Operation test")
758 net_id
= self
._create
_network
()
761 self
._delete
_network
(net_id
)
763 def _get_port_info_request(self
, network_id
, vm_id
):
765 Returns an object of type RwcalYang.YangData_RwProject_Project_VimResources_PortinfoList
767 port
= RwcalYang
.YangData_RwProject_Project_VimResources_PortinfoList()
768 port
.port_name
= 'rift.cal.unittest.port'
769 port
.network_id
= network_id
774 def _create_port(self
, net_id
, vm_id
= None):
776 Create a port in network with network_id: net_id and verifies that operation is successful
779 logger
.info("Openstack-CAL-Test: Creating a port in network with network_id: %s and VM with vm_id: %s" %(net_id
, vm_id
))
781 logger
.info("Openstack-CAL-Test: Creating a port in network with network_id: %s" %(net_id))
784 port
= self
._get
_port
_info
_request
(net_id
, vm_id
)
785 rc
, port_id
= self
.cal
.create_port(self
._acct
, port
)
786 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
789 rc
, rs
= self
.cal
.get_port(self
._acct
, port_id
)
790 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
791 logger
.info("Openstack-CAL-Test: Successfully create Port with id : %s. Port State : %s" %(port_id
, rs
.port_state
))
795 def _delete_port(self
, port_id
):
797 Deletes a port and verifies that operation is successful
799 rc
, rs
= self
.cal
.get_port(self
._acct
, port_id
)
800 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
801 logger
.info("Openstack-CAL-Test: Deleting Port with id : %s. Port State : %s" %(port_id
, rs
.port_state
))
804 self
.cal
.delete_port(self
._acct
, port_id
)
806 rc
, rs
= self
.cal
.get_port_list(self
._acct
)
807 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
808 port_list
= [ port
for port
in rs
.portinfo_list
if port
.port_id
== port_id
]
809 self
.assertEqual(len(port_list
), 0)
810 logger
.info("Openstack-CAL-Test: Successfully Deleted Port with id : %s" %(port_id))
812 def _monitor_port(self
, port_id
, expected_state
):
814 Monitor the port state until it reaches expected_state
817 rc
, rs
= self
.cal
.get_port(self
._acct
, port_id
)
818 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
819 logger
.info("Openstack-CAL-Test: Port with id : %s. Port State : %s" %(port_id
, rs
.port_state
))
820 if rs
.port_state
== expected_state
:
822 rc
, rs
= self
.cal
.get_port(self
._acct
, port_id
)
823 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
824 self
.assertEqual(rs
.port_state
, expected_state
)
825 logger
.info("Openstack-CAL-Test: Port with port_id : %s reached expected state : %s" %(port_id
, rs
.port_state
))
827 @unittest.skip("Skipping test_port_operations_with_vm")
828 def test_port_operations_with_vm(self
):
830 Create/Delete Ports in a network and associate it with a VM
832 logger
.info("Openstack-CAL-Test: Starting Port Operation test with VM")
834 ### First create a network
835 net_id
= self
._create
_network
()
838 data
, vm_id
= self
._create
_vm
(self
._flavor
, self
._image
)
840 ### Now create Port which connects VM to Network
841 port_id
= self
._create
_port
(net_id
, vm_id
)
843 ### Verify that port goes to active state
844 self
._monitor
_port
(port_id
, 'ACTIVE')
847 self
._delete
_vm
(vm_id
)
850 self
._delete
_port
(port_id
)
852 ### Delete the network
853 self
._delete
_network
(net_id
)
855 @unittest.skip("Skipping test_create_vm_with_port")
856 def test_create_vm_with_port(self
):
858 Create VM and add ports to it during boot time.
860 logger
.info("Openstack-CAL-Test: Starting Create VM with port test")
862 ### First create a network
863 net_id
= self
._create
_network
()
865 ### Now create Port which connects VM to Network
866 port_id
= self
._create
_port
(net_id
)
869 data
, vm_id
= self
._create
_vm
(self
._flavor
, self
._image
, [port_id
])
871 ### Verify that port goes to active state
872 self
._monitor
_port
(port_id
, 'ACTIVE')
875 self
._delete
_vm
(vm_id
)
878 self
._delete
_port
(port_id
)
880 ### Delete the network
881 self
._delete
_network
(net_id
)
883 @unittest.skip("Skipping test_get_vdu_list")
884 def test_get_vdu_list(self
):
886 Test the get_vdu_list API
888 logger
.info("Openstack-CAL-Test: Test Get VDU List APIs")
889 rc
, rsp
= self
.cal
.get_vdu_list(self
._acct
)
890 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
891 logger
.info("Openstack-CAL-Test: Received %d VDUs" %(len(rsp
.vdu_info_list
)))
892 for vdu
in rsp
.vdu_info_list
:
893 rc
, vdu2
= self
.cal
.get_vdu(self
._acct
, vdu
.vdu_id
, "")
894 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
895 # Make changes for the third argument (currently None for mgmt_network).
896 # This is the mgmt_network published in the vdur (vdu.mgmt_network).
897 # Pass accordingly as per the use case of the test.
898 self
.assertEqual(vdu2
.vdu_id
, vdu
.vdu_id
)
901 @unittest.skip("Skipping test_get_virtual_link_list")
902 def test_get_virtual_link_list(self
):
904 Test the get_virtual_link_list API
906 logger
.info("Openstack-CAL-Test: Test Get virtual_link List APIs")
907 rc
, rsp
= self
.cal
.get_virtual_link_list(self
._acct
)
908 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
909 logger
.info("Openstack-CAL-Test: Received %d virtual_links" %(len(rsp
.virtual_link_info_list
)))
910 for virtual_link
in rsp
.virtual_link_info_list
:
911 rc
, virtual_link2
= self
.cal
.get_virtual_link(self
._acct
, virtual_link
.virtual_link_id
)
912 self
.assertEqual(virtual_link2
.virtual_link_id
, virtual_link
.virtual_link_id
)
914 def _get_virtual_link_request_info(self
):
916 Returns object of type RwcalYang.YangData_RwProject_Project_VirtualLinkReqParams
918 vlink
= RwcalYang
.YangData_RwProject_Project_VirtualLinkReqParams()
919 vlink
.name
= 'rift.cal.virtual_link'
920 vlink
.subnet
= '192.168.1.0/24'
921 if openstack_info
['physical_network']:
922 vlink
.provider_network
.physical_network
= openstack_info
['physical_network']
923 if openstack_info
['network_type']:
924 vlink
.provider_network
.overlay_type
= openstack_info
['network_type'].upper()
925 if OpenStackTest
.SEG_ID
:
926 vlink
.provider_network
.segmentation_id
= OpenStackTest
.SEG_ID
927 OpenStackTest
.SEG_ID
+= 1
930 def _get_vdu_request_info(self
, virtual_link_id
):
932 Returns object of type RwcalYang.YangData_RwProject_Project_VduInitParams
934 vdu
= RwcalYang
.YangData_RwProject_Project_VduInitParams()
936 vdu
.node_id
= OpenStackTest
.NodeID
937 vdu
.image_id
= self
._image
.id
938 vdu
.vm_flavor
.memory_mb
= 512
939 vdu
.vm_flavor
.vcpu_count
= 1
940 vdu
.vm_flavor
.storage_gb
= 4
941 vdu
.flavor_id
= self
._flavor
.id
942 vdu
.vdu_init
.userdata
= PING_USERDATA
943 vdu
.allocate_public_address
= True
945 meta1
= vdu
.supplemental_boot_data
.custom_meta_data
.add()
946 meta1
.name
= "EMS_IP"
947 meta1
.data_type
= "STRING"
948 meta1
.value
= "10.5.6.6"
949 #meta2 = vdu.supplemental_boot_data.custom_meta_data.add()
950 #meta2.name = "Cluster_data"
951 #meta2.data_type = "JSON"
952 #meta2.value = '''{ "cluster_id": "12" , "vnfc_id": "112" }'''
953 except Exception as e
:
955 #vdu.supplemental_boot_data.boot_data_drive = True
956 customfile1
= vdu
.supplemental_boot_data
.config_file
.add()
957 customfile1
.source
= "abcdef124"
958 customfile1
.dest
= "/tmp/tempfile.txt"
959 customfile2
= vdu
.supplemental_boot_data
.config_file
.add()
960 customfile2
.source
= "123456"
961 customfile2
.dest
= "/tmp/tempfile2.txt"
962 c1
= vdu
.connection_points
.add()
964 c1
.virtual_link_id
= virtual_link_id
965 c1
.type_yang
= 'VIRTIO'
968 def _get_vdu_modify_request_info(self
, vdu_id
, virtual_link_id
):
970 Returns object of type RwcalYang.YangData_RwProject_Project_VduModifyParams
972 vdu
= RwcalYang
.YangData_RwProject_Project_VduModifyParams()
974 c1
= vdu
.connection_points_add
.add()
975 c1
.name
= "c_modify1"
976 c1
.virtual_link_id
= virtual_link_id
980 def _get_rbsh_vdu_request_info(self
, vlink_list
):
982 Returns object of type RwcalYang.YangData_RwProject_Project_VduInitParams
984 vdu
= RwcalYang
.YangData_RwProject_Project_VduInitParams()
985 vdu
.name
= "cal_rbsh_vdu"
986 vdu
.vm_flavor
.memory_mb
= 2048
987 vdu
.vm_flavor
.vcpu_count
= 1
988 vdu
.vm_flavor
.storage_gb
= 10
989 vdu
.flavor_id
= self
._flavor
.id
990 vdu
.allocate_public_address
= True
992 for vl
in vlink_list
:
993 c1
= vdu
.connection_points
.add()
994 c1
.name
= "c_point" + str(ctr
)
996 c1
.virtual_link_id
= vl
997 c1
.type_yang
= 'VIRTIO'
999 vol0
= vdu
.volumes
.add()
1001 vol0
.image
= "mgmt.img"
1003 vol0
.boot_priority
= 0
1004 vol0
.device_bus
= "virtio"
1005 vol0
.device_type
= "disk"
1007 vol1
= vdu
.volumes
.add()
1009 vol1
.image
= "segstore.img"
1011 vol1
.boot_priority
= 1
1012 vol1
.device_bus
= "virtio"
1013 vol1
.device_type
= "disk"
1016 vol2
= vdu
.volumes
.add()
1019 vol2
.boot_priority
= 2
1020 vol2
.device_bus
= "virtio"
1021 vol2
.device_type
= "disk"
1023 # existing volume disk
1024 vol3
= vdu
.volumes
.add()
1027 vol3
.volume_ref
= "volume-ref1"
1028 vol3
.boot_priority
= 3
1029 vol3
.device_bus
= "virtio"
1030 vol3
.device_type
= "disk"
1033 @unittest.skip("Skipping test_create_rbsh_vdu")
1034 def test_create_rbsh_vdu(self
):
1036 Test to create VDU with mgmt port and 3 additional connection points
1038 logger
.info("Openstack-CAL-Test: Test Create Virtual Link API")
1040 for ctr
in range(3):
1041 vlink
= RwcalYang
.YangData_RwProject_Project_VirtualLinkReqParams()
1042 vlink
.name
= 'rift.cal.virtual_link' + str(ctr
)
1043 vlink
.subnet
= '11.0.{}.0/24'.format(str(1 + ctr
))
1045 rc
, rsp
= self
.cal
.create_virtual_link(self
._acct
, vlink
)
1046 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1047 logger
.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp
)
1050 #Check if virtual_link create is successful
1051 rc
, rsp
= self
.cal
.get_virtual_link(self
._acct
, rsp
)
1052 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
1053 self
.assertEqual(rsp
.virtual_link_id
, vlink_id
)
1054 vlink_list
.append(vlink_id
)
1058 vdu_req
= self
._get
_rbsh
_vdu
_request
_info
(vlink_list
)
1059 logger
.info("Openstack-CAL-Test: Test Create RB steelhead VDU API (w/ mgmt port) and 3 CPs")
1061 rc
, rsp
= self
.cal
.create_vdu(self
._acct
, vdu_req
)
1062 logger
.debug("Openstack-CAL-Test: rc %s rsp %s" % (rc
, rsp
))
1063 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1064 logger
.info("Openstack-CAL-Test: Created vdu with Id: %s" %rsp
)
1068 ## Check if VDU get is successful
1069 rc
, rsp
= self
.cal
.get_vdu(self
._acct
, test_vdu_id
, "")
1070 # Make changes for the third argument (currently None for mgmt_network).
1071 # This is the mgmt_network published in the vdur (vdu.mgmt_network).
1072 # Pass accordingly as per the use case of the test.
1073 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1074 logger
.debug("Get VDU response %s", rsp
)
1075 self
.assertEqual(rsp
.vdu_id
, test_vdu_id
)
1077 ### Wait until vdu_state is active
1078 logger
.debug("Waiting 10 secs")
1080 #{'name': 'dp0vhost7', 'connection_point_id': 'dp0vhost7', 'state': 'active', 'virtual_link_id': 'rift.cal.virtual_link', 'ip_address': '192.168.100.6'}
1081 vdu_state
= 'inactive'
1082 cp_state
= 'inactive'
1084 rc
, rsp
= self
.cal
.get_vdu(self
._acct
, test_vdu_id
, "")
1085 # Make changes for the third argument (currently None for mgmt_network).
1086 # This is the mgmt_network published in the vdur (vdu.mgmt_network).
1087 # Pass accordingly as per the use case of the test.
1088 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1089 logger
.info("Openstack-CAL-Test: Iter %d VDU with id : %s. Reached State : %s, mgmt ip %s" %(i
, test_vdu_id
, rsp
.state
, rsp
.management_ip
))
1090 if (rsp
.state
== 'active') and ('management_ip' in rsp
) and ('public_ip' in rsp
):
1091 vdu_state
= 'active'
1092 #'connection_points': [{'name': 'dp0vhost7', 'connection_point_id': 'dp0vhost7', 'state': 'active', 'virtual_link_id': 'rift.cal.virtual_link', 'ip_address': '192.168.100.6'}]
1093 for cp
in rsp
.connection_points
:
1094 logger
.info("Openstack-CAL-Test: Iter %d VDU with id : %s. Reached State : %s CP state %s" %(i
, test_vdu_id
, rsp
.state
, cp
))
1095 logger
.debug("Waiting another 5 secs")
1098 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
1099 self
.assertEqual(rsp
.state
, 'active')
1100 self
.assertEqual(vdu_state
, 'active')
1101 logger
.info("Openstack-CAL-Test: VDU with id : %s reached expected state : %s IP: %s" %(test_vdu_id
, rsp
.state
, rsp
.management_ip
))
1102 logger
.info("Openstack-CAL-Test: VDUInfo: %s" %(rsp))
1103 logger
.info("Waiting for 30 secs before deletion")
1106 ### Check vdu list as well
1107 rc
, rsp
= self
.cal
.get_vdu_list(self
._acct
)
1108 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1110 logger
.debug("Get VDU response %s", rsp
)
1111 for vdu
in rsp
.vdu_info_list
:
1112 if vdu
.vdu_id
== test_vdu_id
:
1114 self
.assertEqual(found
, True)
1115 logger
.info("Openstack-CAL-Test: Passed VDU list" )
1117 #@unittest.skip("Skipping test_create_delete_virtual_link_and_vdu")
1118 def test_create_delete_virtual_link_and_vdu(self
):
1122 logger
.info("Openstack-CAL-Test: Test Create Virtual Link API")
1123 vlink_req
= self
._get
_virtual
_link
_request
_info
()
1125 rc
, rsp
= self
.cal
.create_virtual_link(self
._acct
, vlink_req
)
1126 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1127 logger
.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp
)
1130 #Check if virtual_link create is successful
1131 rc
, rsp
= self
.cal
.get_virtual_link(self
._acct
, rsp
)
1132 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
1133 self
.assertEqual(rsp
.virtual_link_id
, vlink_id
)
1136 vdu_req
= self
._get
_vdu
_request
_info
(vlink_id
)
1137 logger
.info("Openstack-CAL-Test: Test Create VDU API")
1139 rc
, rsp
= self
.cal
.create_vdu(self
._acct
, vdu_req
)
1140 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1141 logger
.info("Openstack-CAL-Test: Created vdu with Id: %s" %rsp
)
1145 ## Check if VDU create is successful
1146 rc
, rsp
= self
.cal
.get_vdu(self
._acct
, rsp
, "")
1147 # Make changes for the third argument (currently None for mgmt_network).
1148 # This is the mgmt_network published in the vdur (vdu.mgmt_network).
1149 # Pass accordingly as per the use case of the test.
1151 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1152 self
.assertEqual(rsp
.vdu_id
, vdu_id
)
1154 ### Wait until vdu_state is active
1156 rc
, rs
= self
.cal
.get_vdu(self
._acct
, vdu_id
, "")
1157 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1158 # Make changes for the third argument (currently None for mgmt_network).
1159 # This is the mgmt_network published in the vdur (vdu.mgmt_network).
1160 # Pass accordingly as per the use case of the test.
1161 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1162 logger
.info("Openstack-CAL-Test: VDU with id : %s. Reached State : %s" %(vdu_id
, rs
.state
))
1163 if rs
.state
== 'active':
1165 rc
, rs
= self
.cal
.get_vdu(self
._acct
, vdu_id
, "")
1166 # Make changes for the third argument (currently None for mgmt_network).
1167 # This is the mgmt_network published in the vdur (vdu.mgmt_network).
1168 # Pass accordingly as per the use case of the test.
1169 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1170 self
.assertEqual(rs
.state
, 'active')
1171 logger
.info("Openstack-CAL-Test: VDU with id : %s reached expected state : %s" %(vdu_id
, rs
.state
))
1172 logger
.info("Openstack-CAL-Test: VDUInfo: %s" %(rs))
1174 vlink_req
= self
._get
_virtual
_link
_request
_info
()
1176 ### Create another virtual_link
1177 rc
, rsp
= self
.cal
.create_virtual_link(self
._acct
, vlink_req
)
1178 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1179 logger
.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp
)
1182 ### Now exercise the modify_vdu_api
1183 #vdu_modify = self._get_vdu_modify_request_info(vdu_id, vlink_id2)
1184 #rc = self.cal.modify_vdu(self._acct, vdu_modify)
1185 #self.assertEqual(rc, RwStatus.SUCCESS)
1186 #logger.info("Openstack-CAL-Test: Modified vdu with Id: %s" %vdu_id)
1188 ### Lets delete the VDU
1189 self
.cal
.delete_vdu(self
._acct
, vdu_id
)
1191 ### Lets delete the Virtual Link
1192 self
.cal
.delete_virtual_link(self
._acct
, vlink_id
)
1194 ### Lets delete the Virtual Link-2
1195 self
.cal
.delete_virtual_link(self
._acct
, vlink_id2
)
1198 ### Verify that VDU and virtual link are successfully deleted
1199 rc
, rsp
= self
.cal
.get_vdu_list(self
._acct
)
1200 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1201 for vdu
in rsp
.vdu_info_list
:
1202 self
.assertNotEqual(vdu
.vdu_id
, vdu_id
)
1204 rc
, rsp
= self
.cal
.get_virtual_link_list(self
._acct
)
1205 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
1207 for virtual_link
in rsp
.virtual_link_info_list
:
1208 self
.assertNotEqual(virtual_link
.virtual_link_id
, vlink_id
)
1210 logger
.info("Openstack-CAL-Test: VDU/Virtual Link create-delete test successfully completed")
1212 def _get_vol_vdu_request_info(self
, vlink_list
):
1214 Returns object of type RwcalYang.YangData_RwProject_Project_VduInitParams
1216 vdu
= RwcalYang
.YangData_RwProject_Project_VduInitParams()
1217 vdu
.name
= "cal_vdu"
1218 vdu
.vm_flavor
.memory_mb
= 512
1219 vdu
.vm_flavor
.vcpu_count
= 1
1220 vdu
.vm_flavor
.storage_gb
= 4
1221 vdu
.allocate_public_address
= True
1223 for vl
in vlink_list
:
1224 c1
= vdu
.connection_points
.add()
1225 c1
.name
= "c_point" + str(ctr
)
1227 c1
.virtual_link_id
= vl
1228 c1
.type_yang
= 'VIRTIO'
1230 vol0
= vdu
.volumes
.add()
1232 vol0
.image
= openstack_info
['reserved_image']
1235 vol0
.boot_priority
= 0
1236 except Exception as e
:
1238 vol0
.device_type
= "disk"
1240 meta1
= vol0
.custom_meta_data
.add()
1241 meta1
.name
= "fs_type"
1242 meta1
.data_type
= "STRING"
1243 meta1
.value
= "ext4"
1244 except Exception as e
:
1249 @unittest.skip("Skipping test_create_vol_vdu")
1250 def test_create_vol_vdu(self
):
1252 Test to create VDU with mgmt port using Volumes
1254 logger
.info("Openstack-CAL-Test: Test Create Virtual Link API")
1256 vlink
= RwcalYang
.YangData_RwProject_Project_VirtualLinkReqParams()
1257 vlink
.name
= 'rift.cal.virtual_link'
1258 vlink
.subnet
= '11.0.1.0/24'
1260 rc
, rsp
= self
.cal
.create_virtual_link(self
._acct
, vlink
)
1261 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1262 logger
.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp
)
1265 #Check if virtual_link create is successful
1266 rc
, rsp
= self
.cal
.get_virtual_link(self
._acct
, rsp
)
1267 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
1268 self
.assertEqual(rsp
.virtual_link_id
, vlink_id
)
1269 vlink_list
.append(vlink_id
)
1272 vdu_req
= self
._get
_vol
_vdu
_request
_info
(vlink_list
)
1273 logger
.info("################################### ")
1274 logger
.info("Openstack-CAL-Test: Test Create VDU API (w/ volumes) ")
1276 rc
, rsp
= self
.cal
.create_vdu(self
._acct
, vdu_req
)
1277 logger
.debug("Openstack-CAL-Test: rc %s rsp %s" % (rc
, rsp
))
1278 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1279 logger
.info("Openstack-CAL-Test: Created vdu with Id: %s" %rsp
)
1283 ## Check if VDU get is successful
1284 rc
, rsp
= self
.cal
.get_vdu(self
._acct
, test_vdu_id
, "")
1285 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1286 # Make changes for the third argument (currently None for mgmt_network).
1287 # This is the mgmt_network published in the vdur (vdu.mgmt_network).
1288 # Pass accordingly as per the use case of the test.
1290 logger
.debug("Get VDU response %s", rsp
)
1291 self
.assertEqual(rsp
.vdu_id
, test_vdu_id
)
1293 ### Wait until vdu_state is active
1294 logger
.debug("Waiting 10 secs")
1296 #{'name': 'dp0vhost7', 'connection_point_id': 'dp0vhost7', 'state': 'active', 'virtual_link_id': 'rift.cal.virtual_link', 'ip_address': '192.168.100.6'}
1297 vdu_state
= 'inactive'
1298 cp_state
= 'inactive'
1300 rc
, rsp
= self
.cal
.get_vdu(self
._acct
, test_vdu_id
, "")
1301 # Make changes for the third argument (currently None for mgmt_network).
1302 # This is the mgmt_network published in the vdur (vdu.mgmt_network).
1303 # Pass accordingly as per the use case of the test.
1304 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1305 logger
.info("Openstack-CAL-Test: VDU with id : %s. Reached State : %s, mgmt ip %s" %(test_vdu_id
, rsp
.state
, rsp
.management_ip
))
1306 if (rsp
.state
== 'active') and ('management_ip' in rsp
) and ('public_ip' in rsp
):
1307 vdu_state
= 'active'
1308 #'connection_points': [{'name': 'dp0vhost7', 'connection_point_id': 'dp0vhost7', 'state': 'active', 'virtual_link_id': 'rift.cal.virtual_link', 'ip_address': '192.168.100.6'}]
1309 for cp
in rsp
.connection_points
:
1310 logger
.info("Openstack-CAL-Test: VDU with id : %s. Reached State : %s CP state %s" %(test_vdu_id
, rsp
.state
, cp
))
1311 if vdu_state
== 'active' and cp
.ip_address
is not None :
1314 logger
.debug("Waiting another 5 secs")
1317 self
.assertEqual(rc
, RwStatus
.SUCCESS
)
1318 self
.assertEqual(rsp
.state
, 'active')
1319 self
.assertEqual(vdu_state
, 'active')
1320 self
.assertEqual(cp_state
, 'active')
1321 logger
.info("Openstack-CAL-Test: VDU with id : %s reached expected state : %s IP: %s" %(test_vdu_id
, rsp
.state
, rsp
.management_ip
))
1322 logger
.info("Openstack-CAL-Test: VDUInfo: %s" %(rsp))
1323 logger
.info("Waiting for 30 secs before deletion")
1326 ### Check vdu list as well
1327 rc
, rsp
= self
.cal
.get_vdu_list(self
._acct
)
1328 self
.assertEqual(rc
.status
, RwStatus
.SUCCESS
)
1330 logger
.debug("Get VDU response %s", rsp
)
1331 for vdu
in rsp
.vdu_info_list
:
1332 if vdu
.vdu_id
== test_vdu_id
:
1334 self
.assertEqual(found
, True)
1335 logger
.info("Openstack-CAL-Test: Passed VDU list" )
1337 @unittest.skip("Skipping test_validate_creds")
1338 def test_validate_creds(self
):
1342 logger
.info("Openstack-CAL-Test: Test validate creds")
1343 status
= self
.cal
.validate_cloud_creds(self
._acct
)
1344 logger
.info("Openstack-CAL-Test: Passed validate creds")
1346 class VmData(object):
1347 """A convenience class that provides all the stats and EPA Attributes
1348 from the VM provided
1350 def __init__(self
, host
, mgmt_ip
):
1353 host (str): host name.
1354 mgmt_ip (str): The IP of the newly created VM.
1356 # Sleep for 20s to ensure the VM is UP and ready to run commands
1358 logger
.info("Connecting to host: {} and IP: {}".format(host
, mgmt_ip
))
1359 self
.client
= paramiko
.SSHClient()
1360 self
.client
.set_missing_host_key_policy(paramiko
.WarningPolicy())
1361 self
.client
.connect(host
)
1364 # Get all data from the newly created VM.
1365 self
._data
= self
._get
_data
()
1366 self
._page
_size
= self
._exec
_and
_clean
("getconf PAGE_SIZE")
1367 self
._disk
_space
= self
._exec
_and
_clean
(
1368 "df -kh --output=size /",
1370 self
._pci
_data
= self
._exec
('lspci -m | grep "10-Gigabit"')
1372 def _get_data(self
,):
1373 """Runs the command and store the output in a python dict.
1376 dict: Containing all key => value pairs.
1379 cmds
= ["lscpu", 'less /proc/meminfo']
1381 ssh_out
= self
._exec
(cmd
)
1382 content
.update(self
._convert
_to
_dict
(ssh_out
))
1385 def _exec_and_clean(self
, cmd
, line_no
=0):
1386 """A convenience method to run a command and extract the specified line
1390 cmd (str): Command to execute
1391 line_no (int, optional): Default to 0, extracts the first line.
1394 str: line_no of the output of the command.
1396 output
= self
._exec
(cmd
)[line_no
]
1397 output
= ' '.join(output
.split())
1398 return output
.strip()
1400 def _exec(self
, cmd
):
1401 """Thin wrapper that runs the command and returns the stdout data
1404 cmd (str): Command to execute.
1407 list: Contains the command output.
1409 _
, ssh_out
, _
= self
.client
.exec_command(
1410 "/usr/rift/bin/ssh_root {} {}".format(self
.ip
,
1412 return ssh_out
.readlines()
1414 def _convert_to_dict(self
, content
):
1415 """convenience method that cleans and stores the line into dict.
1416 data is split based on ":" or " ".
1419 content (list): A list containing the stdout.
1422 dict: containing stat attribute => value.
1425 for line
in content
:
1426 line
= ' '.join(line
.split())
1428 key
, value
= line
.split(":")
1430 key
, value
= line
.split(" ")
1431 key
, value
= key
.strip(), value
.strip()
1432 flattened
[key
] = value
1437 disk
= self
._disk
_space
.replace("G", "")
1441 def numa_node_count(self
):
1442 numa_cores
= self
._data
['NUMA node(s)']
1443 numa_cores
= int(numa_cores
)
1448 cores
= int(self
._data
['CPU(s)'])
1452 def cpu_threads(self
):
1453 threads
= int(self
._data
['Thread(s) per core'])
1458 memory
= self
._data
['MemTotal']
1459 memory
= int(memory
.replace("kB", ""))/1000/1000
1463 def memory_page_size(self
):
1464 return self
._page
_size
1467 def pci_passthrough_device_list(self
):
1468 return self
._pci
_data
1471 if __name__
== "__main__":
1472 #logging.basicConfig(level=logging.DEBUG)
1473 logger
.setLevel(logging
.DEBUG
)