rwcal/test/test_rwcal_openstack.py

   1
   2 #
   3 #   Copyright 2016 RIFT.IO Inc
   4 #
   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
   8 #
   9 #       http://www.apache.org/licenses/LICENSE-2.0
  10 #
  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.
  16 #
  17
  18 import datetime
  19 import logging
  20 import time
  21 import unittest
  22 import hashlib
  23 import novaclient.exceptions as nova_exception
  24 import paramiko
  25 import rw_peas
  26 import rwlogger
  27 from keystoneclient import v3 as ksclient
  28
  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
  32
  33 logger = logging.getLogger('rwcal-openstack')
  34
  35 PING_USERDATA = '''
  36 #cloud-config
  37 password: fedora
  38 chpasswd: { expire: False }
  39 ssh_pwauth: True
  40 '''
  41
  42 #
  43 # Important information about openstack installation. This needs to be manually verified
  44 #
  45 openstack_info = {
  46     'username'           : 'xxxxxx',
  47     'password'           : 'xxxxx',
  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'
  58     }
  59
  60 openstack_V3_info = {
  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'
  71     }
  72
  73
  74 def get_cal_account():
  75     """
  76     Creates an object for class RwcalYang.YangData_RwProject_Project_CloudAccounts_CloudAccountList()
  77     """
  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']
  88     return account
  89
  90 def get_cal_plugin():
  91     """
  92     Loads rw.cal plugin via libpeas
  93     """
  94     plugin = rw_peas.PeasPlugin('rwcal_openstack', 'RwCal-1.0')
  95     engine, info, extension = plugin()
  96
  97     # Get the RwLogger context
  98     rwloggerctx = rwlogger.RwLog.Ctx.new("Cal-Log")
  99
 100     cal = plugin.get_interface("Cloud")
 101     try:
 102         rc = cal.init(rwloggerctx)
 103         assert rc == RwStatus.SUCCESS
 104     except:
 105         logger.error("ERROR:Cal plugin instantiation failed. Aborting tests")
 106     else:
 107         logger.info("Openstack Cal plugin successfully instantiated")
 108     return cal
 109
 110
 111 class OpenStackTest(unittest.TestCase):
 112     NodeID = "123456789012345" # Some random number to test VM tagging
 113     MemoryPageSize = "LARGE"
 114     CpuPolicy = "DEDICATED"
 115     CpuThreadPolicy = "SEPARATE"
 116     CpuThreads = 1
 117     NumaNodeCount = 2
 118     HostTrust = "trusted"
 119     PCIPassThroughAlias = "PCI_10G_ALIAS"
 120     SEG_ID = openstack_info['segmentation_id']
 121
 122     def setUp(self):
 123         """
 124         Assumption:
 125          - It is assumed that openstack install has a flavor and image precreated.
 126          - Flavor_name: x1.xlarge
 127          - Image_name : rwimage
 128
 129         If these resources are not then this test will fail.
 130         """
 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")
 135
 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)
 139
 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]
 143
 144         rc, rs = self.cal.get_image_list(self._acct)
 145         self.assertEqual(rc, RwStatus.SUCCESS)
 146
 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]
 150
 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)
 157
 158     def tearDown(self):
 159         logger.info("Openstack-CAL-Test: tearDown")
 160
 161
 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()
 168
 169     @unittest.skip("Skipping test_list_flavors")
 170     def test_list_flavor(self):
 171         """
 172         List existing flavors from openstack installation
 173         """
 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)
 182
 183     @unittest.skip("Skipping test_list_images")
 184     def test_list_images(self):
 185         """
 186         List existing images from openstack installation
 187         """
 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)
 196
 197     @unittest.skip("Skipping test_list_vms")
 198     def test_list_vms(self):
 199         """
 200         List existing VMs from openstack installation
 201         """
 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)
 209
 210     @unittest.skip("Skipping test_list_networks")
 211     def test_list_networks(self):
 212         """
 213         List existing Network from openstack installation
 214         """
 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)
 222
 223     @unittest.skip("Skipping test_list_ports")
 224     def test_list_ports(self):
 225         """
 226         List existing Ports from openstack installation
 227         """
 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)
 236
 237     def _get_image_info_request(self):
 238         """
 239         Returns request object of type RwcalYang.YangData_RwProject_Project_VimResources_ImageinfoList()
 240         """
 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._md5(img.location)
 247         return img
 248
 249     def _get_image_info(self, img_id):
 250         """
 251         Checks the image status until it becomes active or timeout occurs (100sec)
 252         Returns the image_info dictionary
 253         """
 254         rs = None
 255         rc = None
 256         for i in range(100):
 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':
 261                 break
 262             else:
 263                 time.sleep(2) # Sleep for a second
 264         return rs
 265
 266     @unittest.skip("Skipping test_create_delete_image")
 267     def test_create_delete_image(self):
 268         """
 269         Create/Query/Delete a new image in openstack installation
 270         """
 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))
 286
 287     def _get_flavor_info_request(self):
 288         """
 289         Returns request object of type RwcalYang.YangData_RwProject_Project_VimResources_FlavorinfoList()
 290         """
 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()
 302             node.id = i
 303             if i == 0:
 304                 vcpu = node.vcpu.add()
 305                 vcpu.id = 0
 306                 vcpu = node.vcpu.add()
 307                 vcpu.id = 1
 308             elif i == 1:
 309                 vcpu = node.vcpu.add()
 310                 vcpu.id = 2
 311                 vcpu = node.vcpu.add()
 312                 vcpu.id = 3
 313             node.memory_mb = 8196
 314         dev = flavor.guest_epa.pcie_device.add()
 315         dev.device_id = OpenStackTest.PCIPassThroughAlias
 316         dev.count = 1
 317         return flavor
 318
 319     @unittest.skip("Skipping test_create_delete_flavor")
 320     def test_create_delete_flavor(self):
 321         """
 322         Create/Query/Delete a new flavor in openstack installation
 323         """
 324         logger.info("Openstack-CAL-Test: Starting Image create/delete test")
 325
 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' ]
 330         if flavor_list:
 331             rc = self.cal.delete_flavor(self._acct, flavor_list[0].id)
 332             self.assertEqual(rc, RwStatus.SUCCESS)
 333
 334         flavor = self._get_flavor_info_request()
 335         rc, flavor_id = self.cal.create_flavor(self._acct, flavor)
 336         self.assertEqual(rc, RwStatus.SUCCESS)
 337
 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)
 342
 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))
 361
 362     def _get_vm_info_request(self, flavor_id, image_id):
 363         """
 364         Returns request object of type RwcalYang.VMInfoItem
 365         """
 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
 372         return vm
 373
 374     def _check_vm_state(self, vm_id, expected_state):
 375         """
 376         Wait until VM reaches particular state (expected_state).
 377         """
 378         # Wait while VM goes to required state
 379
 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:
 385                 break
 386             else:
 387                 time.sleep(1)
 388
 389         rc, rs = self.cal.get_vm(self._acct, vm_id)
 390         self.assertEqual(rc, RwStatus.SUCCESS)
 391         self.assertEqual(rs.state, expected_state)
 392
 393     def _create_vm(self, flavor, image, port_list = None):
 394         """
 395         Create VM and perform validity checks
 396         """
 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)
 399
 400         if port_list:
 401             for port_id in port_list:
 402                 port = vm.port_list.add()
 403                 port.port_id = port_id
 404
 405         rc, vm_id = self.cal.create_vm(self._acct, vm)
 406         self.assertEqual(rc, RwStatus.SUCCESS)
 407
 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))
 412
 413         ### Ensure the VM state is active
 414         self._check_vm_state(vm_id, 'ACTIVE')
 415
 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))
 422         return rs, vm_id
 423
 424     def _delete_vm(self, vm_id):
 425         """
 426         Delete VM and perform validity checks
 427         """
 428         rc, rs = self.cal.get_vm(self._acct, vm_id)
 429         self.assertEqual(rc, RwStatus.SUCCESS)
 430
 431         logger.info("Openstack-CAL-Test: Initiating VM Delete operation on VM vm_id : %s. Current VM state : %s " %(vm_id, rs.state))
 432
 433         rc = self.cal.delete_vm(self._acct, vm_id)
 434         self.assertEqual(rc, RwStatus.SUCCESS)
 435
 436         for i in range(50):
 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]
 441             if not len(vm_list):
 442                 break
 443
 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))
 449
 450     def _stop_vm(self, vm_id):
 451         """
 452         Stop VM and perform validity checks
 453         """
 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')
 461
 462
 463     def _start_vm(self, vm_id):
 464         """
 465         Starts VM and performs validity checks
 466         """
 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)
 472
 473         ### Ensure that VM state is ACTIVE
 474         self._check_vm_state(vm_id, 'ACTIVE')
 475
 476
 477     def _reboot_vm(self, vm_id):
 478         """
 479         Reboot VM and perform validity checks
 480         """
 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)
 486
 487         ### Ensure that VM state is ACTIVE
 488         self._check_vm_state(vm_id, 'ACTIVE')
 489
 490     def assert_vm(self, vm_data, flavor):
 491         """Verify the newly created VM for attributes specified in the flavor.
 492
 493         Args:
 494             vm_data (VmData): Instance of the newly created VM
 495             flavor (FlavorInfoItem): Config flavor.
 496         """
 497         vm_config = flavor
 498
 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"]
 503
 504         for field in FIELDS:
 505             if field not in vm_config:
 506                 continue
 507
 508             vm_value = getattr(vm_data, field)
 509             config_value = getattr(vm_config, field)
 510
 511             if field == "memory_page_size":
 512                 config_value = page_lookup[config_value]
 513
 514             if field == "memory":
 515                 config_value = int(config_value/1000)
 516
 517             if field == "pci_passthrough_device_list":
 518                 config_value = len(config_value)
 519                 vm_value = len(vm_value)
 520
 521             self.assertEqual(vm_value, config_value)
 522
 523     @unittest.skip("Skipping test_vm_epa_attributes")
 524     def test_vm_epa_attributes(self):
 525         """
 526         Primary goal: To create a VM with the specified EPA Attributes
 527         Secondary goal: To verify flavor creation/delete
 528         """
 529
 530         logger.info("Openstack-CAL-Test: Starting VM(EPA) create/delete test")
 531         flavor = self._get_flavor_info_request()
 532
 533         rc, flavor_id = self.cal.do_create_flavor(self._acct, flavor)
 534         self.assertEqual(rc, RwStatus.SUCCESS)
 535         flavor.id = flavor_id
 536
 537         data, vm_id = self._create_vm(flavor, self._image)
 538
 539         vm_data = VmData(data.host_name, data.management_ip)
 540         self.assert_vm(vm_data, flavor)
 541
 542         self._delete_vm(vm_id)
 543
 544         rc = self.cal.do_delete_flavor(self._acct, flavor_id)
 545         self.assertEqual(rc, RwStatus.SUCCESS)
 546
 547     '''
 548     @unittest.skip("Skipping test_expiry_token")
 549     def test_expiry_token(self):
 550         """
 551         Primary goal: To verify if we are refreshing the expired tokens.
 552         """
 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'],
 558                 None,
 559                 openstack_info['project_name'])
 560         # Get hold of the client instance need for Token Manager
 561         client = drv._get_keystone_connection()
 562
 563         auth_ref = client.auth_ref
 564         token = auth_ref['auth_token']
 565
 566         # Verify if the newly acquired token works.
 567         nova = NovaDriver(drv)
 568         flavors = nova.flavor_list()
 569         self.assertTrue(len(flavors) > 1)
 570
 571         # Invalidate the token
 572         token_manger = ksclient.tokens.TokenManager(client)
 573         token_manger.revoke_token(token)
 574
 575         time.sleep(10)
 576
 577         unauth_exp = False
 578         try:
 579             flavors = nova.flavor_list()
 580             print (flavors)
 581         except nova_exception.AuthorizationFailure:
 582             unauth_exp = True
 583
 584         self.assertTrue(unauth_exp)
 585
 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
 590
 591         flavors = nova.flavor_list()
 592         self.assertTrue(len(flavors) > 1)
 593
 594     def test_v3_Keystone(self):
 595         # Keystone v3 authentication
 596         auth_exp = False
 597         try:
 598             drv = KeystoneDriverV3(openstack_V3_info['username'],
 599                     openstack_V3_info['password'],
 600                     openstack_V3_info['auth_url'],
 601                     openstack_V3_info['project_name'],
 602                     None,
 603                     openstack_V3_info['user_domain_name'],
 604                     openstack_V3_info['project_domain_name'])
 605             client = drv._get_keystone_connection()
 606         except Exception:
 607             auth_exp = True
 608         self.assertFalse(auth_exp)
 609
 610         # Incorrect domain being to passed to v3 Keystone API
 611         auth_exp = False
 612         try:
 613             drv = KeystoneDriverV3(openstack_V3_info['username'],
 614                     openstack_V3_info['password'],
 615                     openstack_V3_info['auth_url'],
 616                     openstack_V3_info['project_name'],
 617                     None,
 618                     "DummyDom",
 619                     openstack_V3_info['project_domain_name'])
 620             client = drv._get_keystone_connection()
 621         except Exception:
 622             auth_exp = True
 623         self.assertTrue(auth_exp)
 624
 625         # Keystone v3 authentication-Backward compatabilty test
 626         auth_exp = False
 627         try:
 628             drv = KeystoneDriverV3(openstack_info['username'],
 629                     openstack_info['password'],
 630                     openstack_info['auth_url'],
 631                     openstack_info['project_name'],
 632                     None,
 633                     openstack_info['user_domain_name'],
 634                     openstack_info['project_domain_name'])
 635             client = drv._get_keystone_connection()
 636         except Exception:
 637             auth_exp = True
 638         self.assertFalse(auth_exp)
 639
 640         # Keystone v3 authentication-Backward compatabilty
 641         auth_exp = False
 642         try:
 643             drv = KeystoneDriverV3(openstack_info['username'],
 644                     openstack_info['password'],
 645                     openstack_info['auth_url'],
 646                     openstack_info['project_name'],
 647                     None,
 648                     None,
 649                     None)
 650             client = drv._get_keystone_connection()
 651         except Exception:
 652             auth_exp = True
 653         self.assertFalse(auth_exp)
 654
 655         # Keystone v2 authentication
 656         auth_exp = False
 657         try:
 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'],
 663                     None)
 664             client = drv2._get_keystone_connection()
 665         except Exception:
 666             auth_exp = True
 667         self.assertFalse(auth_exp)
 668     '''
 669
 670     @unittest.skip("Skipping test_vm_operations")
 671     def test_vm_operations(self):
 672         """
 673         Primary goal: Create/Query/Delete VM in openstack installation.
 674         Secondary goal: VM pause/resume operations on VM.
 675
 676         """
 677         logger.info("Openstack-CAL-Test: Starting VM Operations test")
 678
 679         # Create VM
 680         data, vm_id = self._create_vm(self._flavor, self._image)
 681
 682         # Stop VM
 683         self._stop_vm(vm_id)
 684         # Start VM
 685         self._start_vm(vm_id)
 686
 687         vm_data = VmData(data.host_name, data.management_ip)
 688         self.assert_vm(vm_data, self._flavor)
 689
 690         # Reboot VM
 691         self._reboot_vm(vm_id)
 692         ### Delete the VM
 693         self._delete_vm(vm_id)
 694
 695
 696     def _get_network_info_request(self):
 697         """
 698         Returns request object of type RwcalYang.YangData_RwProject_Project_VimResources_NetworkinfoList
 699         """
 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
 710         return network
 711
 712
 713     def _create_network(self):
 714         """
 715         Create a network and verify that network creation is successful
 716         """
 717         network = self._get_network_info_request()
 718
 719         ### Create network
 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)
 723
 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 ))
 728
 729         return net_id
 730
 731     def _delete_network(self, net_id):
 732         """
 733         Delete network and verify that delete operation is successful
 734         """
 735         rc, rs = self.cal.get_network(self._acct, net_id)
 736         self.assertEqual(rc, RwStatus.SUCCESS)
 737
 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)
 741
 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))
 748
 749
 750     @unittest.skip("Skipping test_network_operations")
 751     def test_network_operations(self):
 752         """
 753         Create/Delete Networks
 754         """
 755         logger.info("Openstack-CAL-Test: Starting Network Operation test")
 756
 757         ### Create Network
 758         net_id = self._create_network()
 759
 760         ### Delete Network
 761         self._delete_network(net_id)
 762
 763     def _get_port_info_request(self, network_id, vm_id):
 764         """
 765         Returns an object of type RwcalYang.YangData_RwProject_Project_VimResources_PortinfoList
 766         """
 767         port = RwcalYang.YangData_RwProject_Project_VimResources_PortinfoList()
 768         port.port_name = 'rift.cal.unittest.port'
 769         port.network_id = network_id
 770         if vm_id != None:
 771             port.vm_id = vm_id
 772         return port
 773
 774     def _create_port(self, net_id, vm_id = None):
 775         """
 776         Create a port in network with network_id: net_id and verifies that operation is successful
 777         """
 778         if vm_id != None:
 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))
 780         else:
 781             logger.info("Openstack-CAL-Test: Creating a port in network with network_id: %s" %(net_id))
 782
 783         ### Create Port
 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)
 787
 788         ### Get Port
 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))
 792
 793         return port_id
 794
 795     def _delete_port(self, port_id):
 796         """
 797         Deletes a port and verifies that operation is successful
 798         """
 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))
 802
 803         ### Delete Port
 804         self.cal.delete_port(self._acct, port_id)
 805
 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))
 811
 812     def _monitor_port(self, port_id, expected_state):
 813         """
 814         Monitor the port state until it reaches expected_state
 815         """
 816         for i in range(50):
 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:
 821                 break
 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))
 826
 827     @unittest.skip("Skipping test_port_operations_with_vm")
 828     def test_port_operations_with_vm(self):
 829         """
 830         Create/Delete Ports in a network and associate it with a VM
 831         """
 832         logger.info("Openstack-CAL-Test: Starting Port Operation test with VM")
 833
 834         ### First create a network
 835         net_id = self._create_network()
 836
 837         ### Create a VM
 838         data, vm_id = self._create_vm(self._flavor, self._image)
 839
 840         ### Now create Port which connects VM to Network
 841         port_id = self._create_port(net_id, vm_id)
 842
 843         ### Verify that port goes to active state
 844         self._monitor_port(port_id, 'ACTIVE')
 845
 846         ### Delete VM
 847         self._delete_vm(vm_id)
 848
 849         ### Delete Port
 850         self._delete_port(port_id)
 851
 852         ### Delete the network
 853         self._delete_network(net_id)
 854
 855     @unittest.skip("Skipping test_create_vm_with_port")
 856     def test_create_vm_with_port(self):
 857         """
 858         Create VM and add ports to it during boot time.
 859         """
 860         logger.info("Openstack-CAL-Test: Starting Create VM with port test")
 861
 862         ### First create a network
 863         net_id = self._create_network()
 864
 865         ### Now create Port which connects VM to Network
 866         port_id = self._create_port(net_id)
 867
 868         ### Create a VM
 869         data, vm_id = self._create_vm(self._flavor, self._image, [port_id])
 870
 871         ### Verify that port goes to active state
 872         self._monitor_port(port_id, 'ACTIVE')
 873
 874         ### Delete VM
 875         self._delete_vm(vm_id)
 876
 877         ### Delete Port
 878         self._delete_port(port_id)
 879
 880         ### Delete the network
 881         self._delete_network(net_id)
 882
 883     @unittest.skip("Skipping test_get_vdu_list")
 884     def test_get_vdu_list(self):
 885         """
 886         Test the get_vdu_list API
 887         """
 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)
 899
 900
 901     @unittest.skip("Skipping test_get_virtual_link_list")
 902     def test_get_virtual_link_list(self):
 903         """
 904         Test the get_virtual_link_list API
 905         """
 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)
 913
 914     def _get_virtual_link_request_info(self):
 915         """
 916         Returns object of type RwcalYang.YangData_RwProject_Project_VirtualLinkReqParams
 917         """
 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
 928         return vlink
 929
 930     def _get_vdu_request_info(self, virtual_link_id):
 931         """
 932         Returns object of type RwcalYang.YangData_RwProject_Project_VduInitParams
 933         """
 934         vdu = RwcalYang.YangData_RwProject_Project_VduInitParams()
 935         vdu.name = "cal.vdu"
 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
 944         try:
 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:
 954             pass
 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()
 963         c1.name = "c_point1"
 964         c1.virtual_link_id = virtual_link_id
 965         c1.type_yang = 'VIRTIO'
 966         return vdu
 967
 968     def _get_vdu_modify_request_info(self, vdu_id, virtual_link_id):
 969         """
 970         Returns object of type RwcalYang.YangData_RwProject_Project_VduModifyParams
 971         """
 972         vdu = RwcalYang.YangData_RwProject_Project_VduModifyParams()
 973         vdu.vdu_id = vdu_id
 974         c1 = vdu.connection_points_add.add()
 975         c1.name = "c_modify1"
 976         c1.virtual_link_id = virtual_link_id
 977
 978         return vdu
 979
 980     def _get_rbsh_vdu_request_info(self, vlink_list):
 981           """
 982           Returns object of type RwcalYang.YangData_RwProject_Project_VduInitParams
 983           """
 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
 991           ctr = 0
 992           for vl in vlink_list:
 993              c1 = vdu.connection_points.add()
 994              c1.name = "c_point" + str(ctr)
 995              ctr += 1
 996              c1.virtual_link_id = vl
 997              c1.type_yang = 'VIRTIO'
 998
 999           vol0 = vdu.volumes.add()
1000           vol0.name = "vda"
1001           vol0.image = "mgmt.img"
1002           vol0.size = 40
1003           vol0.boot_priority = 0
1004           vol0.device_bus = "virtio"
1005           vol0.device_type = "disk"
1006
1007           vol1 = vdu.volumes.add()
1008           vol1.name = "vdb"
1009           vol1.image = "segstore.img"
1010           vol1.size = 60
1011           vol1.boot_priority = 1
1012           vol1.device_bus = "virtio"
1013           vol1.device_type = "disk"
1014
1015           # blank disk
1016           vol2 = vdu.volumes.add()
1017           vol2.name = "vdc"
1018           vol2.size = 10
1019           vol2.boot_priority = 2
1020           vol2.device_bus = "virtio"
1021           vol2.device_type = "disk"
1022
1023           # existing volume disk
1024           vol3 = vdu.volumes.add()
1025           vol3.name = "vdd"
1026           vol3.size = 10
1027           vol3.volume_ref = "volume-ref1"
1028           vol3.boot_priority = 3
1029           vol3.device_bus = "virtio"
1030           vol3.device_type = "disk"
1031           return vdu
1032
1033     @unittest.skip("Skipping test_create_rbsh_vdu")
1034     def test_create_rbsh_vdu(self):
1035           """
1036           Test to create VDU with mgmt port and 3 additional connection points
1037           """
1038           logger.info("Openstack-CAL-Test: Test Create Virtual Link API")
1039           vlink_list = []
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))
1044
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)
1048              vlink_id = rsp
1049
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)
1055
1056
1057           # Now create VDU
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")
1060
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)
1065
1066           test_vdu_id = rsp
1067
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)
1076
1077           ### Wait until vdu_state is active
1078           logger.debug("Waiting 10 secs")
1079           time.sleep(10)
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'
1083           for i in range(15):
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")
1096               time.sleep(5)
1097
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")
1104           time.sleep(30)
1105
1106           ### Check vdu list as well
1107           rc, rsp = self.cal.get_vdu_list(self._acct)
1108           self.assertEqual(rc.status, RwStatus.SUCCESS)
1109           found = False
1110           logger.debug("Get VDU response %s", rsp)
1111           for vdu in rsp.vdu_info_list:
1112               if vdu.vdu_id == test_vdu_id:
1113                  found = True
1114           self.assertEqual(found, True)
1115           logger.info("Openstack-CAL-Test: Passed VDU list" )
1116
1117     #@unittest.skip("Skipping test_create_delete_virtual_link_and_vdu")
1118     def test_create_delete_virtual_link_and_vdu(self):
1119         """
1120         Test to create VDU
1121         """
1122         logger.info("Openstack-CAL-Test: Test Create Virtual Link API")
1123         vlink_req = self._get_virtual_link_request_info()
1124
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)
1128         vlink_id = rsp
1129
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)
1134
1135         # Now create VDU
1136         vdu_req = self._get_vdu_request_info(vlink_id)
1137         logger.info("Openstack-CAL-Test: Test Create VDU API")
1138
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)
1142
1143         vdu_id = rsp
1144
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.
1150
1151         self.assertEqual(rc.status, RwStatus.SUCCESS)
1152         self.assertEqual(rsp.vdu_id, vdu_id)
1153
1154         ### Wait until vdu_state is active
1155         for i in range(50):
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':
1164                 break
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))
1173
1174         vlink_req = self._get_virtual_link_request_info()
1175
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)
1180         vlink_id2= rsp
1181
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)
1187
1188         ### Lets delete the VDU
1189         self.cal.delete_vdu(self._acct, vdu_id)
1190
1191         ### Lets delete the Virtual Link
1192         self.cal.delete_virtual_link(self._acct, vlink_id)
1193
1194         ### Lets delete the Virtual Link-2
1195         self.cal.delete_virtual_link(self._acct, vlink_id2)
1196
1197         time.sleep(5)
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)
1203
1204         rc, rsp = self.cal.get_virtual_link_list(self._acct)
1205         self.assertEqual(rc, RwStatus.SUCCESS)
1206
1207         for virtual_link in rsp.virtual_link_info_list:
1208             self.assertNotEqual(virtual_link.virtual_link_id, vlink_id)
1209
1210         logger.info("Openstack-CAL-Test: VDU/Virtual Link create-delete test successfully completed")
1211
1212     def _get_vol_vdu_request_info(self, vlink_list):
1213           """
1214           Returns object of type RwcalYang.YangData_RwProject_Project_VduInitParams
1215           """
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
1222           ctr = 0
1223           for vl in vlink_list:
1224              c1 = vdu.connection_points.add()
1225              c1.name = "c_point" + str(ctr)
1226              ctr += 1
1227              c1.virtual_link_id = vl
1228              c1.type_yang = 'VIRTIO'
1229
1230           vol0 = vdu.volumes.add()
1231           vol0.name = "vda"
1232           vol0.image = openstack_info['reserved_image']
1233           vol0.size = 10
1234           try:
1235               vol0.boot_priority = 0
1236           except Exception as e:
1237               pass
1238           vol0.device_type = "disk"
1239           try:
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:
1245              pass
1246
1247           return vdu
1248
1249     @unittest.skip("Skipping test_create_vol_vdu")
1250     def test_create_vol_vdu(self):
1251           """
1252           Test to create VDU with mgmt port using Volumes
1253           """
1254           logger.info("Openstack-CAL-Test: Test Create Virtual Link API")
1255           vlink_list = []
1256           vlink = RwcalYang.YangData_RwProject_Project_VirtualLinkReqParams()
1257           vlink.name = 'rift.cal.virtual_link'
1258           vlink.subnet = '11.0.1.0/24'
1259
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)
1263           vlink_id = rsp
1264
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)
1270
1271           # Now create VDU
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) ")
1275
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)
1280
1281           test_vdu_id = rsp
1282
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.
1289
1290           logger.debug("Get VDU response %s", rsp)
1291           self.assertEqual(rsp.vdu_id, test_vdu_id)
1292
1293           ### Wait until vdu_state is active
1294           logger.debug("Waiting 10 secs")
1295           time.sleep(10)
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'
1299           for i in range(5):
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 :
1312                           cp_state = 'active'
1313                           break
1314               logger.debug("Waiting another 5 secs")
1315               time.sleep(5)
1316
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")
1324           time.sleep(30)
1325
1326           ### Check vdu list as well
1327           rc, rsp = self.cal.get_vdu_list(self._acct)
1328           self.assertEqual(rc.status, RwStatus.SUCCESS)
1329           found = False
1330           logger.debug("Get VDU response %s", rsp)
1331           for vdu in rsp.vdu_info_list:
1332               if vdu.vdu_id == test_vdu_id:
1333                  found = True
1334           self.assertEqual(found, True)
1335           logger.info("Openstack-CAL-Test: Passed VDU list" )
1336
1337     @unittest.skip("Skipping test_validate_creds")
1338     def test_validate_creds(self):
1339           """
1340           Test validate creds
1341           """
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")
1345
1346 class VmData(object):
1347     """A convenience class that provides all the stats and EPA Attributes
1348     from the VM provided
1349     """
1350     def __init__(self, host, mgmt_ip):
1351         """
1352         Args:
1353             host (str): host name.
1354             mgmt_ip (str): The IP of the newly created VM.
1355         """
1356         # Sleep for 20s to ensure the VM is UP and ready to run commands
1357         time.sleep(20)
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)
1362         self.ip = mgmt_ip
1363
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 /",
1369                 line_no=1)
1370         self._pci_data = self._exec('lspci -m | grep "10-Gigabit"')
1371
1372     def _get_data(self,):
1373         """Runs the command and store the output in a python dict.
1374
1375         Returns:
1376             dict: Containing all key => value pairs.
1377         """
1378         content = {}
1379         cmds = ["lscpu", 'less /proc/meminfo']
1380         for cmd in cmds:
1381             ssh_out = self._exec(cmd)
1382             content.update(self._convert_to_dict(ssh_out))
1383         return content
1384
1385     def _exec_and_clean(self, cmd, line_no=0):
1386         """A convenience method to run a command and extract the specified line
1387         number.
1388
1389         Args:
1390             cmd (str): Command to execute
1391             line_no (int, optional): Default to 0, extracts the first line.
1392
1393         Returns:
1394             str: line_no of the output of the command.
1395         """
1396         output = self._exec(cmd)[line_no]
1397         output = ' '.join(output.split())
1398         return output.strip()
1399
1400     def _exec(self, cmd):
1401         """Thin wrapper that runs the command and returns the stdout data
1402
1403         Args:
1404             cmd (str): Command to execute.
1405
1406         Returns:
1407             list: Contains the command output.
1408         """
1409         _, ssh_out, _ = self.client.exec_command(
1410                 "/usr/rift/bin/ssh_root {} {}".format(self.ip,
1411                                                       cmd))
1412         return ssh_out.readlines()
1413
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 " ".
1417
1418         Args:
1419             content (list): A list containing the stdout.
1420
1421         Returns:
1422             dict: containing stat attribute => value.
1423         """
1424         flattened = {}
1425         for line in content:
1426             line = ' '.join(line.split())
1427             if ":" in line:
1428                 key, value = line.split(":")
1429             else:
1430                 key, value = line.split(" ")
1431             key, value = key.strip(), value.strip()
1432             flattened[key] = value
1433         return flattened
1434
1435     @property
1436     def disk(self):
1437         disk = self._disk_space.replace("G", "")
1438         return int(disk)
1439
1440     @property
1441     def numa_node_count(self):
1442         numa_cores = self._data['NUMA node(s)']
1443         numa_cores = int(numa_cores)
1444         return numa_cores
1445
1446     @property
1447     def vcpus(self):
1448         cores = int(self._data['CPU(s)'])
1449         return cores
1450
1451     @property
1452     def cpu_threads(self):
1453         threads = int(self._data['Thread(s) per core'])
1454         return threads
1455
1456     @property
1457     def memory(self):
1458         memory = self._data['MemTotal']
1459         memory = int(memory.replace("kB", ""))/1000/1000
1460         return int(memory)
1461
1462     @property
1463     def memory_page_size(self):
1464         return self._page_size
1465
1466     @property
1467     def pci_passthrough_device_list(self):
1468         return self._pci_data
1469
1470
1471 if __name__ == "__main__":
1472     #logging.basicConfig(level=logging.DEBUG)
1473     logger.setLevel(logging.DEBUG)
1474     unittest.main()