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'           : 'pluto',
  47     'password'           : 'mypasswd',
  48     'auth_url'           : 'http://10.66.4.17:5000/v3/',
  49     'project_name'       : 'demo',
  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.CloudAccount()
  77     """
  78     account                          = RwcalYang.CloudAccount()
  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.ImageInfoItem()
 240         """
 241         img = RwcalYang.ImageInfoItem()
 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.FlavorInfoItem()
 290         """
 291         flavor                                     = RwcalYang.FlavorInfoItem()
 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.VMInfoItem()
 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     @unittest.skip("Skipping test_expiry_token")
 548     def test_expiry_token(self):
 549         """
 550         Primary goal: To verify if we are refreshing the expired tokens.
 551         """
 552         logger.info("Openstack-CAL-Test: Starting token refresh test")
 553         drv = KeystoneDriver(
 554                 openstack_info['username'],
 555                 openstack_info['password'],
 556                 openstack_info['auth_url'],
 557                 None,
 558                 openstack_info['project_name'])
 559         # Get hold of the client instance need for Token Manager
 560         client = drv._get_keystone_connection()
 561
 562         auth_ref = client.auth_ref
 563         token = auth_ref['auth_token']
 564
 565         # Verify if the newly acquired token works.
 566         nova = NovaDriver(drv)
 567         flavors = nova.flavor_list()
 568         self.assertTrue(len(flavors) > 1)
 569
 570         # Invalidate the token
 571         token_manger = ksclient.tokens.TokenManager(client)
 572         token_manger.revoke_token(token)
 573
 574         time.sleep(10)
 575
 576         unauth_exp = False
 577         try:
 578             flavors = nova.flavor_list()
 579             print (flavors)
 580         except nova_exception.AuthorizationFailure:
 581             unauth_exp = True
 582
 583         self.assertTrue(unauth_exp)
 584
 585         # Explicitly reset the expire time, to test if we acquire a new token
 586         now = datetime.datetime.utcnow()
 587         time_str = format(now, "%Y-%m-%dT%H:%M:%S.%fZ")
 588         drv._get_keystone_connection().auth_ref['expires_at'] = time_str
 589
 590         flavors = nova.flavor_list()
 591         self.assertTrue(len(flavors) > 1)
 592
 593     def test_v3_Keystone(self):
 594         # Keystone v3 authentication
 595         auth_exp = False
 596         try:
 597             drv = KeystoneDriverV3(openstack_V3_info['username'],
 598                     openstack_V3_info['password'],
 599                     openstack_V3_info['auth_url'],
 600                     openstack_V3_info['project_name'],
 601                     None,
 602                     openstack_V3_info['user_domain_name'],
 603                     openstack_V3_info['project_domain_name'])
 604             client = drv._get_keystone_connection()
 605         except Exception:
 606             auth_exp = True
 607         self.assertFalse(auth_exp)
 608
 609         # Incorrect domain being to passed to v3 Keystone API
 610         auth_exp = False
 611         try:
 612             drv = KeystoneDriverV3(openstack_V3_info['username'],
 613                     openstack_V3_info['password'],
 614                     openstack_V3_info['auth_url'],
 615                     openstack_V3_info['project_name'],
 616                     None,
 617                     "DummyDom",
 618                     openstack_V3_info['project_domain_name'])
 619             client = drv._get_keystone_connection()
 620         except Exception:
 621             auth_exp = True
 622         self.assertTrue(auth_exp)
 623
 624         # Keystone v3 authentication-Backward compatabilty test
 625         auth_exp = False
 626         try:
 627             drv = KeystoneDriverV3(openstack_info['username'],
 628                     openstack_info['password'],
 629                     openstack_info['auth_url'],
 630                     openstack_info['project_name'],
 631                     None,
 632                     openstack_info['user_domain_name'],
 633                     openstack_info['project_domain_name'])
 634             client = drv._get_keystone_connection()
 635         except Exception:
 636             auth_exp = True
 637         self.assertFalse(auth_exp)
 638
 639         # Keystone v3 authentication-Backward compatabilty
 640         auth_exp = False
 641         try:
 642             drv = KeystoneDriverV3(openstack_info['username'],
 643                     openstack_info['password'],
 644                     openstack_info['auth_url'],
 645                     openstack_info['project_name'],
 646                     None,
 647                     None,
 648                     None)
 649             client = drv._get_keystone_connection()
 650         except Exception:
 651             auth_exp = True
 652         self.assertFalse(auth_exp)
 653
 654         # Keystone v2 authentication
 655         auth_exp = False
 656         try:
 657             drv2 = KeystoneDriverV2(
 658                     openstack_info['username'],
 659                     openstack_info['password'],
 660                     'http://10.66.4.17:5000/v2.0',
 661                     openstack_info['project_name'],
 662                     None)
 663             client = drv2._get_keystone_connection()
 664         except Exception:
 665             auth_exp = True
 666         self.assertFalse(auth_exp)
 667
 668     @unittest.skip("Skipping test_vm_operations")
 669     def test_vm_operations(self):
 670         """
 671         Primary goal: Create/Query/Delete VM in openstack installation.
 672         Secondary goal: VM pause/resume operations on VM.
 673
 674         """
 675         logger.info("Openstack-CAL-Test: Starting VM Operations test")
 676
 677         # Create VM
 678         data, vm_id = self._create_vm(self._flavor, self._image)
 679
 680         # Stop VM
 681         self._stop_vm(vm_id)
 682         # Start VM
 683         self._start_vm(vm_id)
 684
 685         vm_data = VmData(data.host_name, data.management_ip)
 686         self.assert_vm(vm_data, self._flavor)
 687
 688         # Reboot VM
 689         self._reboot_vm(vm_id)
 690         ### Delete the VM
 691         self._delete_vm(vm_id)
 692
 693
 694     def _get_network_info_request(self):
 695         """
 696         Returns request object of type RwcalYang.NetworkInfoItem
 697         """
 698         network                            = RwcalYang.NetworkInfoItem()
 699         network.network_name               = 'rift.cal.unittest.network'
 700         network.subnet                     = '192.168.16.0/24'
 701         if openstack_info['physical_network']:
 702             network.provider_network.physical_network = openstack_info['physical_network']
 703         if openstack_info['network_type']:
 704             network.provider_network.overlay_type     = openstack_info['network_type']
 705         if OpenStackTest.SEG_ID:
 706             network.provider_network.segmentation_id  = OpenStackTest.SEG_ID
 707             OpenStackTest.SEG_ID += 1
 708         return network
 709
 710
 711     def _create_network(self):
 712         """
 713         Create a network and verify that network creation is successful
 714         """
 715         network = self._get_network_info_request()
 716
 717         ### Create network
 718         logger.info("Openstack-CAL-Test: Creating a network with name : %s" %(network.network_name))
 719         rc, net_id = self.cal.create_network(self._acct, network)
 720         self.assertEqual(rc, RwStatus.SUCCESS)
 721
 722         ### Verify network is created successfully
 723         rc, rs = self.cal.get_network(self._acct, net_id)
 724         self.assertEqual(rc, RwStatus.SUCCESS)
 725         logger.info("Openstack-CAL-Test: Successfully create Network : %s  with id : %s." %(network.network_name, net_id ))
 726
 727         return net_id
 728
 729     def _delete_network(self, net_id):
 730         """
 731         Delete network and verify that delete operation is successful
 732         """
 733         rc, rs = self.cal.get_network(self._acct, net_id)
 734         self.assertEqual(rc, RwStatus.SUCCESS)
 735
 736         logger.info("Openstack-CAL-Test: Deleting a network with id : %s. " %(net_id))
 737         rc = self.cal.delete_network(self._acct, net_id)
 738         self.assertEqual(rc, RwStatus.SUCCESS)
 739
 740         # Verify that network is no longer available via get_network_list API
 741         rc, rs = self.cal.get_network_list(self._acct)
 742         self.assertEqual(rc, RwStatus.SUCCESS)
 743         network_info = [ network for network in rs.networkinfo_list if network.network_id == net_id ]
 744         self.assertEqual(len(network_info), 0)
 745         logger.info("Openstack-CAL-Test: Successfully deleted Network with id : %s" %(net_id))
 746
 747
 748     @unittest.skip("Skipping test_network_operations")
 749     def test_network_operations(self):
 750         """
 751         Create/Delete Networks
 752         """
 753         logger.info("Openstack-CAL-Test: Starting Network Operation test")
 754
 755         ### Create Network
 756         net_id = self._create_network()
 757
 758         ### Delete Network
 759         self._delete_network(net_id)
 760
 761     def _get_port_info_request(self, network_id, vm_id):
 762         """
 763         Returns an object of type RwcalYang.PortInfoItem
 764         """
 765         port = RwcalYang.PortInfoItem()
 766         port.port_name = 'rift.cal.unittest.port'
 767         port.network_id = network_id
 768         if vm_id != None:
 769             port.vm_id = vm_id
 770         return port
 771
 772     def _create_port(self, net_id, vm_id = None):
 773         """
 774         Create a port in network with network_id: net_id and verifies that operation is successful
 775         """
 776         if vm_id != None:
 777             logger.info("Openstack-CAL-Test: Creating a port in network with network_id: %s and VM with vm_id: %s" %(net_id, vm_id))
 778         else:
 779             logger.info("Openstack-CAL-Test: Creating a port in network with network_id: %s" %(net_id))
 780
 781         ### Create Port
 782         port = self._get_port_info_request(net_id, vm_id)
 783         rc, port_id = self.cal.create_port(self._acct, port)
 784         self.assertEqual(rc, RwStatus.SUCCESS)
 785
 786         ### Get Port
 787         rc, rs = self.cal.get_port(self._acct, port_id)
 788         self.assertEqual(rc, RwStatus.SUCCESS)
 789         logger.info("Openstack-CAL-Test: Successfully create Port with id : %s. Port State :  %s" %(port_id, rs.port_state))
 790
 791         return port_id
 792
 793     def _delete_port(self, port_id):
 794         """
 795         Deletes a port and verifies that operation is successful
 796         """
 797         rc, rs = self.cal.get_port(self._acct, port_id)
 798         self.assertEqual(rc, RwStatus.SUCCESS)
 799         logger.info("Openstack-CAL-Test: Deleting Port with id : %s. Port State :  %s" %(port_id, rs.port_state))
 800
 801         ### Delete Port
 802         self.cal.delete_port(self._acct, port_id)
 803
 804         rc, rs = self.cal.get_port_list(self._acct)
 805         self.assertEqual(rc, RwStatus.SUCCESS)
 806         port_list = [ port for port in rs.portinfo_list if port.port_id == port_id ]
 807         self.assertEqual(len(port_list), 0)
 808         logger.info("Openstack-CAL-Test: Successfully Deleted Port with id : %s" %(port_id))
 809
 810     def _monitor_port(self, port_id, expected_state):
 811         """
 812         Monitor the port state until it reaches expected_state
 813         """
 814         for i in range(50):
 815             rc, rs = self.cal.get_port(self._acct, port_id)
 816             self.assertEqual(rc, RwStatus.SUCCESS)
 817             logger.info("Openstack-CAL-Test: Port with id : %s. Port State :  %s" %(port_id, rs.port_state))
 818             if rs.port_state == expected_state:
 819                 break
 820         rc, rs = self.cal.get_port(self._acct, port_id)
 821         self.assertEqual(rc, RwStatus.SUCCESS)
 822         self.assertEqual(rs.port_state, expected_state)
 823         logger.info("Openstack-CAL-Test: Port with port_id : %s reached expected state  : %s" %(port_id, rs.port_state))
 824
 825     @unittest.skip("Skipping test_port_operations_with_vm")
 826     def test_port_operations_with_vm(self):
 827         """
 828         Create/Delete Ports in a network and associate it with a VM
 829         """
 830         logger.info("Openstack-CAL-Test: Starting Port Operation test with VM")
 831
 832         ### First create a network
 833         net_id = self._create_network()
 834
 835         ### Create a VM
 836         data, vm_id = self._create_vm(self._flavor, self._image)
 837
 838         ### Now create Port which connects VM to Network
 839         port_id = self._create_port(net_id, vm_id)
 840
 841         ### Verify that port goes to active state
 842         self._monitor_port(port_id, 'ACTIVE')
 843
 844         ### Delete VM
 845         self._delete_vm(vm_id)
 846
 847         ### Delete Port
 848         self._delete_port(port_id)
 849
 850         ### Delete the network
 851         self._delete_network(net_id)
 852
 853     @unittest.skip("Skipping test_create_vm_with_port")
 854     def test_create_vm_with_port(self):
 855         """
 856         Create VM and add ports to it during boot time.
 857         """
 858         logger.info("Openstack-CAL-Test: Starting Create VM with port test")
 859
 860         ### First create a network
 861         net_id = self._create_network()
 862
 863         ### Now create Port which connects VM to Network
 864         port_id = self._create_port(net_id)
 865
 866         ### Create a VM
 867         data, vm_id = self._create_vm(self._flavor, self._image, [port_id])
 868
 869         ### Verify that port goes to active state
 870         self._monitor_port(port_id, 'ACTIVE')
 871
 872         ### Delete VM
 873         self._delete_vm(vm_id)
 874
 875         ### Delete Port
 876         self._delete_port(port_id)
 877
 878         ### Delete the network
 879         self._delete_network(net_id)
 880
 881     @unittest.skip("Skipping test_get_vdu_list")
 882     def test_get_vdu_list(self):
 883         """
 884         Test the get_vdu_list API
 885         """
 886         logger.info("Openstack-CAL-Test: Test Get VDU List APIs")
 887         rc, rsp = self.cal.get_vdu_list(self._acct)
 888         self.assertEqual(rc, RwStatus.SUCCESS)
 889         logger.info("Openstack-CAL-Test: Received %d VDUs" %(len(rsp.vdu_info_list)))
 890         for vdu in rsp.vdu_info_list:
 891             rc, vdu2 = self.cal.get_vdu(self._acct, vdu.vdu_id)
 892             self.assertEqual(vdu2.vdu_id, vdu.vdu_id)
 893
 894
 895     @unittest.skip("Skipping test_get_virtual_link_list")
 896     def test_get_virtual_link_list(self):
 897         """
 898         Test the get_virtual_link_list API
 899         """
 900         logger.info("Openstack-CAL-Test: Test Get virtual_link List APIs")
 901         rc, rsp = self.cal.get_virtual_link_list(self._acct)
 902         self.assertEqual(rc, RwStatus.SUCCESS)
 903         logger.info("Openstack-CAL-Test: Received %d virtual_links" %(len(rsp.virtual_link_info_list)))
 904         for virtual_link in rsp.virtual_link_info_list:
 905             rc, virtual_link2 = self.cal.get_virtual_link(self._acct, virtual_link.virtual_link_id)
 906             self.assertEqual(virtual_link2.virtual_link_id, virtual_link.virtual_link_id)
 907
 908     def _get_virtual_link_request_info(self):
 909         """
 910         Returns object of type RwcalYang.VirtualLinkReqParams
 911         """
 912         vlink = RwcalYang.VirtualLinkReqParams()
 913         vlink.name = 'rift.cal.virtual_link'
 914         vlink.subnet = '192.168.1.0/24'
 915         if openstack_info['physical_network']:
 916             vlink.provider_network.physical_network = openstack_info['physical_network']
 917         if openstack_info['network_type']:
 918             vlink.provider_network.overlay_type     = openstack_info['network_type'].upper()
 919         if OpenStackTest.SEG_ID:
 920             vlink.provider_network.segmentation_id  = OpenStackTest.SEG_ID
 921             OpenStackTest.SEG_ID += 1
 922         return vlink
 923
 924     def _get_vdu_request_info(self, virtual_link_id):
 925         """
 926         Returns object of type RwcalYang.VDUInitParams
 927         """
 928         vdu = RwcalYang.VDUInitParams()
 929         vdu.name = "cal.vdu"
 930         vdu.node_id = OpenStackTest.NodeID
 931         vdu.image_id = self._image.id
 932         vdu.flavor_id = self._flavor.id
 933         vdu.vdu_init.userdata = PING_USERDATA
 934         vdu.allocate_public_address = True
 935         meta1 = vdu.supplemental_boot_data.custom_meta_data.add()
 936         meta1.name = "EMS_IP"
 937         meta1.data_type = "STRING"
 938         meta1.value = "10.5.6.6"
 939         #meta2 = vdu.supplemental_boot_data.custom_meta_data.add()
 940         #meta2.name = "Cluster_data"
 941         #meta2.data_type = "JSON"
 942         #meta2.value = '''{ "cluster_id": "12" , "vnfc_id": "112" }'''
 943         #vdu.supplemental_boot_data.boot_data_drive = True
 944         customfile1 = vdu.supplemental_boot_data.config_file.add()
 945         customfile1.source = "abcdef124"
 946         customfile1.dest = "/tmp/tempfile.txt"
 947         customfile2 = vdu.supplemental_boot_data.config_file.add()
 948         customfile2.source = "123456"
 949         customfile2.dest = "/tmp/tempfile2.txt"
 950         c1 = vdu.connection_points.add()
 951         c1.name = "c_point1"
 952         c1.virtual_link_id = virtual_link_id
 953         c1.type_yang = 'VIRTIO'
 954         return vdu
 955
 956     def _get_vdu_modify_request_info(self, vdu_id, virtual_link_id):
 957         """
 958         Returns object of type RwcalYang.VDUModifyParams
 959         """
 960         vdu = RwcalYang.VDUModifyParams()
 961         vdu.vdu_id = vdu_id
 962         c1 = vdu.connection_points_add.add()
 963         c1.name = "c_modify1"
 964         c1.virtual_link_id = virtual_link_id
 965
 966         return vdu
 967
 968     @unittest.skip("Skipping test_create_delete_virtual_link_and_vdu")
 969     def test_create_delete_virtual_link_and_vdu(self):
 970         """
 971         Test to create VDU
 972         """
 973         logger.info("Openstack-CAL-Test: Test Create Virtual Link API")
 974         vlink_req = self._get_virtual_link_request_info()
 975
 976         rc, rsp = self.cal.create_virtual_link(self._acct, vlink_req)
 977         self.assertEqual(rc.status, RwStatus.SUCCESS)
 978         logger.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp)
 979         vlink_id = rsp
 980
 981         #Check if virtual_link create is successful
 982         rc, rsp = self.cal.get_virtual_link(self._acct, rsp)
 983         self.assertEqual(rc, RwStatus.SUCCESS)
 984         self.assertEqual(rsp.virtual_link_id, vlink_id)
 985
 986         # Now create VDU
 987         vdu_req = self._get_vdu_request_info(vlink_id)
 988         logger.info("Openstack-CAL-Test: Test Create VDU API")
 989
 990         rc, rsp = self.cal.create_vdu(self._acct, vdu_req)
 991         self.assertEqual(rc.status, RwStatus.SUCCESS)
 992         logger.info("Openstack-CAL-Test: Created vdu with Id: %s" %rsp)
 993
 994         vdu_id = rsp
 995
 996         ## Check if VDU create is successful
 997         rc, rsp = self.cal.get_vdu(self._acct, rsp)
 998         self.assertEqual(rsp.vdu_id, vdu_id)
 999
1000         ### Wait until vdu_state is active
1001         for i in range(50):
1002             rc, rs = self.cal.get_vdu(self._acct, vdu_id)
1003             self.assertEqual(rc, RwStatus.SUCCESS)
1004             logger.info("Openstack-CAL-Test: VDU with id : %s. Reached State :  %s" %(vdu_id, rs.state))
1005             if rs.state == 'active':
1006                 break
1007         rc, rs = self.cal.get_vdu(self._acct, vdu_id)
1008         self.assertEqual(rc, RwStatus.SUCCESS)
1009         self.assertEqual(rs.state, 'active')
1010         logger.info("Openstack-CAL-Test: VDU with id : %s reached expected state  : %s" %(vdu_id, rs.state))
1011         logger.info("Openstack-CAL-Test: VDUInfo: %s" %(rs))
1012
1013         vlink_req = self._get_virtual_link_request_info()
1014
1015         ### Create another virtual_link
1016         rc, rsp = self.cal.create_virtual_link(self._acct, vlink_req)
1017         self.assertEqual(rc.status, RwStatus.SUCCESS)
1018         logger.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp)
1019         vlink_id2= rsp
1020
1021         ### Now exercise the modify_vdu_api
1022         vdu_modify = self._get_vdu_modify_request_info(vdu_id, vlink_id2)
1023         rc = self.cal.modify_vdu(self._acct, vdu_modify)
1024         self.assertEqual(rc, RwStatus.SUCCESS)
1025         logger.info("Openstack-CAL-Test: Modified vdu with Id: %s" %vdu_id)
1026
1027         ### Lets delete the VDU
1028         self.cal.delete_vdu(self._acct, vdu_id)
1029
1030         ### Lets delete the Virtual Link
1031         self.cal.delete_virtual_link(self._acct, vlink_id)
1032
1033         ### Lets delete the Virtual Link-2
1034         self.cal.delete_virtual_link(self._acct, vlink_id2)
1035
1036         time.sleep(5)
1037         ### Verify that VDU and virtual link are successfully deleted
1038         rc, rsp = self.cal.get_vdu_list(self._acct)
1039         self.assertEqual(rc, RwStatus.SUCCESS)
1040         for vdu in rsp.vdu_info_list:
1041             self.assertNotEqual(vdu.vdu_id, vdu_id)
1042
1043         rc, rsp = self.cal.get_virtual_link_list(self._acct)
1044         self.assertEqual(rc, RwStatus.SUCCESS)
1045
1046         for virtual_link in rsp.virtual_link_info_list:
1047             self.assertNotEqual(virtual_link.virtual_link_id, vlink_id)
1048
1049         logger.info("Openstack-CAL-Test: VDU/Virtual Link create-delete test successfully completed")
1050
1051     def _get_vol_vdu_request_info(self, vlink_list):
1052           """
1053           Returns object of type RwcalYang.VDUInitParams
1054           """
1055           vdu = RwcalYang.VDUInitParams()
1056           vdu.name = "cal_vdu"
1057           vdu.flavor_id = self._flavor.id
1058           vdu.allocate_public_address = True
1059           ctr = 0
1060           for vl in vlink_list:
1061              c1 = vdu.connection_points.add()
1062              c1.name = "c_point" + str(ctr)
1063              ctr += 1
1064              c1.virtual_link_id = vl
1065              c1.type_yang = 'VIRTIO'
1066
1067           vol0 = vdu.volumes.add()
1068           vol0.name = "vda"
1069           vol0.image = openstack_info['reserved_image']
1070           vol0.size = 10
1071           vol0.boot_priority = 0
1072           vol0.device_type = "disk"
1073           meta1 = vol0.custom_meta_data.add()
1074           meta1.name = "fs_type"
1075           meta1.data_type = "STRING"
1076           meta1.value = "ext4"
1077
1078           return vdu
1079
1080     #@unittest.skip("Skipping test_create_vol_vdu")
1081     def test_create_vol_vdu(self):
1082           """
1083           Test to create VDU with mgmt port using Volumes
1084           """
1085           logger.info("Openstack-CAL-Test: Test Create Virtual Link API")
1086           vlink_list = []
1087           vlink = RwcalYang.VirtualLinkReqParams()
1088           vlink.name = 'rift.cal.virtual_link'
1089           vlink.subnet = '11.0.1.0/24'
1090
1091           rc, rsp = self.cal.create_virtual_link(self._acct, vlink)
1092           self.assertEqual(rc.status, RwStatus.SUCCESS)
1093           logger.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp)
1094           vlink_id = rsp
1095
1096           #Check if virtual_link create is successful
1097           rc, rsp = self.cal.get_virtual_link(self._acct, rsp)
1098           self.assertEqual(rc, RwStatus.SUCCESS)
1099           self.assertEqual(rsp.virtual_link_id, vlink_id)
1100           vlink_list.append(vlink_id)
1101
1102           # Now create VDU
1103           vdu_req = self._get_vol_vdu_request_info(vlink_list)
1104           logger.info("################################### ")
1105           logger.info("Openstack-CAL-Test: Test Create VDU API (w/ volumes) ")
1106
1107           rc, rsp = self.cal.create_vdu(self._acct, vdu_req)
1108           logger.debug("Openstack-CAL-Test: rc %s rsp %s" % (rc, rsp))
1109           self.assertEqual(rc.status, RwStatus.SUCCESS)
1110           logger.info("Openstack-CAL-Test: Created vdu with Id: %s" %rsp)
1111
1112           test_vdu_id = rsp
1113
1114           ## Check if VDU get is successful
1115           rc, rsp = self.cal.get_vdu(self._acct, test_vdu_id)
1116           logger.debug("Get VDU response %s", rsp)
1117           self.assertEqual(rsp.vdu_id, test_vdu_id)
1118
1119           ### Wait until vdu_state is active
1120           logger.debug("Waiting 10 secs")
1121           time.sleep(10)
1122           #{'name': 'dp0vhost7', 'connection_point_id': 'dp0vhost7', 'state': 'active', 'virtual_link_id': 'rift.cal.virtual_link', 'ip_address': '192.168.100.6'}
1123           vdu_state = 'inactive'
1124           cp_state = 'inactive'
1125           for i in range(5):
1126               rc, rsp = self.cal.get_vdu(self._acct, test_vdu_id)
1127               self.assertEqual(rc, RwStatus.SUCCESS)
1128               logger.info("Openstack-CAL-Test: VDU with id : %s. Reached State :  %s, mgmt ip %s" %(test_vdu_id, rsp.state, rsp.management_ip))
1129               if (rsp.state == 'active') and ('management_ip' in rsp) and ('public_ip' in rsp):
1130                   vdu_state = 'active'
1131                   #'connection_points': [{'name': 'dp0vhost7', 'connection_point_id': 'dp0vhost7', 'state': 'active', 'virtual_link_id': 'rift.cal.virtual_link', 'ip_address': '192.168.100.6'}]
1132                   for cp in rsp.connection_points:
1133                       logger.info("Openstack-CAL-Test: VDU with id : %s. Reached State :  %s CP state %s" %(test_vdu_id, rsp.state, cp))
1134                       if vdu_state == 'active' and cp.ip_address is not None :
1135                           cp_state = 'active'
1136                           break
1137               logger.debug("Waiting another 5 secs")
1138               time.sleep(5)
1139
1140           self.assertEqual(rc, RwStatus.SUCCESS)
1141           self.assertEqual(rsp.state, 'active')
1142           self.assertEqual(vdu_state, 'active')
1143           self.assertEqual(cp_state, 'active')
1144           logger.info("Openstack-CAL-Test: VDU with id : %s reached expected state  : %s IP: %s" %(test_vdu_id, rsp.state, rsp.management_ip))
1145           logger.info("Openstack-CAL-Test: VDUInfo: %s" %(rsp))
1146           logger.info("Waiting for 30 secs before deletion")
1147           time.sleep(30)
1148
1149           ### Check vdu list as well
1150           rc, rsp = self.cal.get_vdu_list(self._acct)
1151           self.assertEqual(rc, RwStatus.SUCCESS)
1152           found = False
1153           logger.debug("Get VDU response %s", rsp)
1154           for vdu in rsp.vdu_info_list:
1155               if vdu.vdu_id == test_vdu_id:
1156                  found = True
1157           self.assertEqual(found, True)
1158           logger.info("Openstack-CAL-Test: Passed VDU list" )
1159
1160 class VmData(object):
1161     """A convenience class that provides all the stats and EPA Attributes
1162     from the VM provided
1163     """
1164     def __init__(self, host, mgmt_ip):
1165         """
1166         Args:
1167             host (str): host name.
1168             mgmt_ip (str): The IP of the newly created VM.
1169         """
1170         # Sleep for 20s to ensure the VM is UP and ready to run commands
1171         time.sleep(20)
1172         logger.info("Connecting to host: {} and IP: {}".format(host, mgmt_ip))
1173         self.client = paramiko.SSHClient()
1174         self.client.set_missing_host_key_policy(paramiko.WarningPolicy())
1175         self.client.connect(host)
1176         self.ip = mgmt_ip
1177
1178         # Get all data from the newly created VM.
1179         self._data = self._get_data()
1180         self._page_size = self._exec_and_clean("getconf PAGE_SIZE")
1181         self._disk_space = self._exec_and_clean(
1182                 "df -kh --output=size /",
1183                 line_no=1)
1184         self._pci_data = self._exec('lspci -m | grep "10-Gigabit"')
1185
1186     def _get_data(self,):
1187         """Runs the command and store the output in a python dict.
1188
1189         Returns:
1190             dict: Containing all key => value pairs.
1191         """
1192         content = {}
1193         cmds = ["lscpu", 'less /proc/meminfo']
1194         for cmd in cmds:
1195             ssh_out = self._exec(cmd)
1196             content.update(self._convert_to_dict(ssh_out))
1197         return content
1198
1199     def _exec_and_clean(self, cmd, line_no=0):
1200         """A convenience method to run a command and extract the specified line
1201         number.
1202
1203         Args:
1204             cmd (str): Command to execute
1205             line_no (int, optional): Default to 0, extracts the first line.
1206
1207         Returns:
1208             str: line_no of the output of the command.
1209         """
1210         output = self._exec(cmd)[line_no]
1211         output = ' '.join(output.split())
1212         return output.strip()
1213
1214     def _exec(self, cmd):
1215         """Thin wrapper that runs the command and returns the stdout data
1216
1217         Args:
1218             cmd (str): Command to execute.
1219
1220         Returns:
1221             list: Contains the command output.
1222         """
1223         _, ssh_out, _ = self.client.exec_command(
1224                 "/usr/rift/bin/ssh_root {} {}".format(self.ip,
1225                                                       cmd))
1226         return ssh_out.readlines()
1227
1228     def _convert_to_dict(self, content):
1229         """convenience method that cleans and stores the line into dict.
1230         data is split based on ":" or " ".
1231
1232         Args:
1233             content (list): A list containing the stdout.
1234
1235         Returns:
1236             dict: containing stat attribute => value.
1237         """
1238         flattened = {}
1239         for line in content:
1240             line = ' '.join(line.split())
1241             if ":" in line:
1242                 key, value = line.split(":")
1243             else:
1244                 key, value = line.split(" ")
1245             key, value = key.strip(), value.strip()
1246             flattened[key] = value
1247         return flattened
1248
1249     @property
1250     def disk(self):
1251         disk = self._disk_space.replace("G", "")
1252         return int(disk)
1253
1254     @property
1255     def numa_node_count(self):
1256         numa_cores = self._data['NUMA node(s)']
1257         numa_cores = int(numa_cores)
1258         return numa_cores
1259
1260     @property
1261     def vcpus(self):
1262         cores = int(self._data['CPU(s)'])
1263         return cores
1264
1265     @property
1266     def cpu_threads(self):
1267         threads = int(self._data['Thread(s) per core'])
1268         return threads
1269
1270     @property
1271     def memory(self):
1272         memory = self._data['MemTotal']
1273         memory = int(memory.replace("kB", ""))/1000/1000
1274         return int(memory)
1275
1276     @property
1277     def memory_page_size(self):
1278         return self._page_size
1279
1280     @property
1281     def pci_passthrough_device_list(self):
1282         return self._pci_data
1283
1284
1285 if __name__ == "__main__":
1286     #logging.basicConfig(level=logging.DEBUG)
1287     logger.setLevel(logging.DEBUG)
1288     unittest.main()