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'           : 'xxxxxx',
  48     'auth_url'           : 'http://10.66.4.102:5000/v2.0/',
  49     'project_name'       : 'xxxxxx',
  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     '''
 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.NetworkInfoItem
 699         """
 700         network                            = RwcalYang.NetworkInfoItem()
 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.PortInfoItem
 766         """
 767         port = RwcalYang.PortInfoItem()
 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, 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(vdu2.vdu_id, vdu.vdu_id)
 895
 896
 897     @unittest.skip("Skipping test_get_virtual_link_list")
 898     def test_get_virtual_link_list(self):
 899         """
 900         Test the get_virtual_link_list API
 901         """
 902         logger.info("Openstack-CAL-Test: Test Get virtual_link List APIs")
 903         rc, rsp = self.cal.get_virtual_link_list(self._acct)
 904         self.assertEqual(rc, RwStatus.SUCCESS)
 905         logger.info("Openstack-CAL-Test: Received %d virtual_links" %(len(rsp.virtual_link_info_list)))
 906         for virtual_link in rsp.virtual_link_info_list:
 907             rc, virtual_link2 = self.cal.get_virtual_link(self._acct, virtual_link.virtual_link_id)
 908             self.assertEqual(virtual_link2.virtual_link_id, virtual_link.virtual_link_id)
 909
 910     def _get_virtual_link_request_info(self):
 911         """
 912         Returns object of type RwcalYang.VirtualLinkReqParams
 913         """
 914         vlink = RwcalYang.VirtualLinkReqParams()
 915         vlink.name = 'rift.cal.virtual_link'
 916         vlink.subnet = '192.168.1.0/24'
 917         if openstack_info['physical_network']:
 918             vlink.provider_network.physical_network = openstack_info['physical_network']
 919         if openstack_info['network_type']:
 920             vlink.provider_network.overlay_type     = openstack_info['network_type'].upper()
 921         if OpenStackTest.SEG_ID:
 922             vlink.provider_network.segmentation_id  = OpenStackTest.SEG_ID
 923             OpenStackTest.SEG_ID += 1
 924         return vlink
 925
 926     def _get_vdu_request_info(self, virtual_link_id):
 927         """
 928         Returns object of type RwcalYang.VDUInitParams
 929         """
 930         vdu = RwcalYang.VDUInitParams()
 931         vdu.name = "cal.vdu"
 932         vdu.node_id = OpenStackTest.NodeID
 933         vdu.image_id = self._image.id
 934         vdu.vm_flavor.memory_mb = 512
 935         vdu.vm_flavor.vcpu_count = 1
 936         vdu.vm_flavor.storage_gb = 4
 937         vdu.flavor_id = self._flavor.id
 938         vdu.vdu_init.userdata = PING_USERDATA
 939         vdu.allocate_public_address = True
 940         try:
 941             meta1 = vdu.supplemental_boot_data.custom_meta_data.add()
 942             meta1.name = "EMS_IP"
 943             meta1.data_type = "STRING"
 944             meta1.value = "10.5.6.6"
 945             #meta2 = vdu.supplemental_boot_data.custom_meta_data.add()
 946             #meta2.name = "Cluster_data"
 947             #meta2.data_type = "JSON"
 948             #meta2.value = '''{ "cluster_id": "12" , "vnfc_id": "112" }'''
 949         except Exception as e:
 950             pass
 951         #vdu.supplemental_boot_data.boot_data_drive = True
 952         customfile1 = vdu.supplemental_boot_data.config_file.add()
 953         customfile1.source = "abcdef124"
 954         customfile1.dest = "/tmp/tempfile.txt"
 955         customfile2 = vdu.supplemental_boot_data.config_file.add()
 956         customfile2.source = "123456"
 957         customfile2.dest = "/tmp/tempfile2.txt"
 958         c1 = vdu.connection_points.add()
 959         c1.name = "c_point1"
 960         c1.virtual_link_id = virtual_link_id
 961         c1.type_yang = 'VIRTIO'
 962         return vdu
 963
 964     def _get_vdu_modify_request_info(self, vdu_id, virtual_link_id):
 965         """
 966         Returns object of type RwcalYang.VDUModifyParams
 967         """
 968         vdu = RwcalYang.VDUModifyParams()
 969         vdu.vdu_id = vdu_id
 970         c1 = vdu.connection_points_add.add()
 971         c1.name = "c_modify1"
 972         c1.virtual_link_id = virtual_link_id
 973
 974         return vdu
 975
 976     def _get_rbsh_vdu_request_info(self, vlink_list):
 977           """
 978           Returns object of type RwcalYang.VDUInitParams
 979           """
 980           vdu = RwcalYang.VDUInitParams()
 981           vdu.name = "cal_rbsh_vdu"
 982           vdu.vm_flavor.memory_mb = 2048
 983           vdu.vm_flavor.vcpu_count = 1
 984           vdu.vm_flavor.storage_gb = 10
 985           vdu.flavor_id = self._flavor.id
 986           vdu.allocate_public_address = True
 987           ctr = 0
 988           for vl in vlink_list:
 989              c1 = vdu.connection_points.add()
 990              c1.name = "c_point" + str(ctr)
 991              ctr += 1
 992              c1.virtual_link_id = vl
 993              c1.type_yang = 'VIRTIO'
 994
 995           vol0 = vdu.volumes.add()
 996           vol0.name = "vda"
 997           vol0.image = "mgmt.img"
 998           vol0.size = 40
 999           vol0.boot_priority = 0
1000           vol0.device_bus = "virtio"
1001           vol0.device_type = "disk"
1002
1003           vol1 = vdu.volumes.add()
1004           vol1.name = "vdb"
1005           vol1.image = "segstore.img"
1006           vol1.size = 60
1007           vol1.boot_priority = 1
1008           vol1.device_bus = "virtio"
1009           vol1.device_type = "disk"
1010
1011           # blank disk
1012           vol2 = vdu.volumes.add()
1013           vol2.name = "vdc"
1014           vol2.size = 10
1015           vol2.boot_priority = 2
1016           vol2.device_bus = "virtio"
1017           vol2.device_type = "disk"
1018
1019           # existing volume disk
1020           vol3 = vdu.volumes.add()
1021           vol3.name = "vdd"
1022           vol3.size = 10
1023           vol3.volume_ref = "volume-ref1"
1024           vol3.boot_priority = 3
1025           vol3.device_bus = "virtio"
1026           vol3.device_type = "disk"
1027           return vdu
1028
1029     @unittest.skip("Skipping test_create_rbsh_vdu")
1030     def test_create_rbsh_vdu(self):
1031           """
1032           Test to create VDU with mgmt port and 3 additional connection points
1033           """
1034           logger.info("Openstack-CAL-Test: Test Create Virtual Link API")
1035           vlink_list = []
1036           for ctr in range(3):
1037              vlink = RwcalYang.VirtualLinkReqParams()
1038              vlink.name = 'rift.cal.virtual_link' + str(ctr)
1039              vlink.subnet = '11.0.{}.0/24'.format(str(1 + ctr))
1040
1041              rc, rsp = self.cal.create_virtual_link(self._acct, vlink)
1042              self.assertEqual(rc.status, RwStatus.SUCCESS)
1043              logger.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp)
1044              vlink_id = rsp
1045
1046              #Check if virtual_link create is successful
1047              rc, rsp = self.cal.get_virtual_link(self._acct, rsp)
1048              self.assertEqual(rc, RwStatus.SUCCESS)
1049              self.assertEqual(rsp.virtual_link_id, vlink_id)
1050              vlink_list.append(vlink_id)
1051
1052
1053           # Now create VDU
1054           vdu_req = self._get_rbsh_vdu_request_info(vlink_list)
1055           logger.info("Openstack-CAL-Test: Test Create RB steelhead VDU API (w/ mgmt port) and 3 CPs")
1056
1057           rc, rsp = self.cal.create_vdu(self._acct, vdu_req)
1058           logger.debug("Openstack-CAL-Test: rc %s rsp %s" % (rc, rsp))
1059           self.assertEqual(rc.status, RwStatus.SUCCESS)
1060           logger.info("Openstack-CAL-Test: Created vdu with Id: %s" %rsp)
1061
1062           test_vdu_id = rsp
1063
1064           ## Check if VDU get is successful
1065           rc, rsp = self.cal.get_vdu(self._acct, test_vdu_id)
1066           logger.debug("Get VDU response %s", rsp)
1067           self.assertEqual(rsp.vdu_id, test_vdu_id)
1068
1069           ### Wait until vdu_state is active
1070           logger.debug("Waiting 10 secs")
1071           time.sleep(10)
1072           #{'name': 'dp0vhost7', 'connection_point_id': 'dp0vhost7', 'state': 'active', 'virtual_link_id': 'rift.cal.virtual_link', 'ip_address': '192.168.100.6'}
1073           vdu_state = 'inactive'
1074           cp_state = 'inactive'
1075           for i in range(15):
1076               rc, rsp = self.cal.get_vdu(self._acct, test_vdu_id)
1077               self.assertEqual(rc, RwStatus.SUCCESS)
1078               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))
1079               if (rsp.state == 'active') and ('management_ip' in rsp) and ('public_ip' in rsp):
1080                   vdu_state = 'active'
1081                   #'connection_points': [{'name': 'dp0vhost7', 'connection_point_id': 'dp0vhost7', 'state': 'active', 'virtual_link_id': 'rift.cal.virtual_link', 'ip_address': '192.168.100.6'}]
1082                   for cp in rsp.connection_points:
1083                       logger.info("Openstack-CAL-Test: Iter %d VDU with id : %s. Reached State :  %s CP state %s" %(i, test_vdu_id, rsp.state, cp))
1084               logger.debug("Waiting another 5 secs")
1085               time.sleep(5)
1086
1087           self.assertEqual(rc, RwStatus.SUCCESS)
1088           self.assertEqual(rsp.state, 'active')
1089           self.assertEqual(vdu_state, 'active')
1090           logger.info("Openstack-CAL-Test: VDU with id : %s reached expected state  : %s IP: %s" %(test_vdu_id, rsp.state, rsp.management_ip))
1091           logger.info("Openstack-CAL-Test: VDUInfo: %s" %(rsp))
1092           logger.info("Waiting for 30 secs before deletion")
1093           time.sleep(30)
1094
1095           ### Check vdu list as well
1096           rc, rsp = self.cal.get_vdu_list(self._acct)
1097           self.assertEqual(rc, RwStatus.SUCCESS)
1098           found = False
1099           logger.debug("Get VDU response %s", rsp)
1100           for vdu in rsp.vdu_info_list:
1101               if vdu.vdu_id == test_vdu_id:
1102                  found = True
1103           self.assertEqual(found, True)
1104           logger.info("Openstack-CAL-Test: Passed VDU list" )
1105
1106     #@unittest.skip("Skipping test_create_delete_virtual_link_and_vdu")
1107     def test_create_delete_virtual_link_and_vdu(self):
1108         """
1109         Test to create VDU
1110         """
1111         logger.info("Openstack-CAL-Test: Test Create Virtual Link API")
1112         vlink_req = self._get_virtual_link_request_info()
1113
1114         rc, rsp = self.cal.create_virtual_link(self._acct, vlink_req)
1115         self.assertEqual(rc.status, RwStatus.SUCCESS)
1116         logger.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp)
1117         vlink_id = rsp
1118
1119         #Check if virtual_link create is successful
1120         rc, rsp = self.cal.get_virtual_link(self._acct, rsp)
1121         self.assertEqual(rc, RwStatus.SUCCESS)
1122         self.assertEqual(rsp.virtual_link_id, vlink_id)
1123
1124         # Now create VDU
1125         vdu_req = self._get_vdu_request_info(vlink_id)
1126         logger.info("Openstack-CAL-Test: Test Create VDU API")
1127
1128         rc, rsp = self.cal.create_vdu(self._acct, vdu_req)
1129         self.assertEqual(rc.status, RwStatus.SUCCESS)
1130         logger.info("Openstack-CAL-Test: Created vdu with Id: %s" %rsp)
1131
1132         vdu_id = rsp
1133
1134         ## Check if VDU create is successful
1135         rc, rsp = self.cal.get_vdu(self._acct, rsp)
1136         self.assertEqual(rsp.vdu_id, vdu_id)
1137
1138         ### Wait until vdu_state is active
1139         for i in range(50):
1140             rc, rs = self.cal.get_vdu(self._acct, vdu_id)
1141             self.assertEqual(rc, RwStatus.SUCCESS)
1142             logger.info("Openstack-CAL-Test: VDU with id : %s. Reached State :  %s" %(vdu_id, rs.state))
1143             if rs.state == 'active':
1144                 break
1145         rc, rs = self.cal.get_vdu(self._acct, vdu_id)
1146         self.assertEqual(rc, RwStatus.SUCCESS)
1147         self.assertEqual(rs.state, 'active')
1148         logger.info("Openstack-CAL-Test: VDU with id : %s reached expected state  : %s" %(vdu_id, rs.state))
1149         logger.info("Openstack-CAL-Test: VDUInfo: %s" %(rs))
1150
1151         vlink_req = self._get_virtual_link_request_info()
1152
1153         ### Create another virtual_link
1154         rc, rsp = self.cal.create_virtual_link(self._acct, vlink_req)
1155         self.assertEqual(rc.status, RwStatus.SUCCESS)
1156         logger.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp)
1157         vlink_id2= rsp
1158
1159         ### Now exercise the modify_vdu_api
1160         #vdu_modify = self._get_vdu_modify_request_info(vdu_id, vlink_id2)
1161         #rc = self.cal.modify_vdu(self._acct, vdu_modify)
1162         #self.assertEqual(rc, RwStatus.SUCCESS)
1163         #logger.info("Openstack-CAL-Test: Modified vdu with Id: %s" %vdu_id)
1164
1165         ### Lets delete the VDU
1166         self.cal.delete_vdu(self._acct, vdu_id)
1167
1168         ### Lets delete the Virtual Link
1169         self.cal.delete_virtual_link(self._acct, vlink_id)
1170
1171         ### Lets delete the Virtual Link-2
1172         self.cal.delete_virtual_link(self._acct, vlink_id2)
1173
1174         time.sleep(5)
1175         ### Verify that VDU and virtual link are successfully deleted
1176         rc, rsp = self.cal.get_vdu_list(self._acct)
1177         self.assertEqual(rc, RwStatus.SUCCESS)
1178         for vdu in rsp.vdu_info_list:
1179             self.assertNotEqual(vdu.vdu_id, vdu_id)
1180
1181         rc, rsp = self.cal.get_virtual_link_list(self._acct)
1182         self.assertEqual(rc, RwStatus.SUCCESS)
1183
1184         for virtual_link in rsp.virtual_link_info_list:
1185             self.assertNotEqual(virtual_link.virtual_link_id, vlink_id)
1186
1187         logger.info("Openstack-CAL-Test: VDU/Virtual Link create-delete test successfully completed")
1188
1189     def _get_vol_vdu_request_info(self, vlink_list):
1190           """
1191           Returns object of type RwcalYang.VDUInitParams
1192           """
1193           vdu = RwcalYang.VDUInitParams()
1194           vdu.name = "cal_vdu"
1195           vdu.vm_flavor.memory_mb = 512
1196           vdu.vm_flavor.vcpu_count = 1
1197           vdu.vm_flavor.storage_gb = 4
1198           vdu.allocate_public_address = True
1199           ctr = 0
1200           for vl in vlink_list:
1201              c1 = vdu.connection_points.add()
1202              c1.name = "c_point" + str(ctr)
1203              ctr += 1
1204              c1.virtual_link_id = vl
1205              c1.type_yang = 'VIRTIO'
1206
1207           vol0 = vdu.volumes.add()
1208           vol0.name = "vda"
1209           vol0.image = openstack_info['reserved_image']
1210           vol0.size = 10
1211           try:
1212               vol0.boot_priority = 0
1213           except Exception as e:
1214               pass
1215           vol0.device_type = "disk"
1216           try:
1217              meta1 = vol0.custom_meta_data.add()
1218              meta1.name = "fs_type"
1219              meta1.data_type = "STRING"
1220              meta1.value = "ext4"
1221           except Exception as e:
1222              pass
1223
1224           return vdu
1225
1226     @unittest.skip("Skipping test_create_vol_vdu")
1227     def test_create_vol_vdu(self):
1228           """
1229           Test to create VDU with mgmt port using Volumes
1230           """
1231           logger.info("Openstack-CAL-Test: Test Create Virtual Link API")
1232           vlink_list = []
1233           vlink = RwcalYang.VirtualLinkReqParams()
1234           vlink.name = 'rift.cal.virtual_link'
1235           vlink.subnet = '11.0.1.0/24'
1236
1237           rc, rsp = self.cal.create_virtual_link(self._acct, vlink)
1238           self.assertEqual(rc.status, RwStatus.SUCCESS)
1239           logger.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp)
1240           vlink_id = rsp
1241
1242           #Check if virtual_link create is successful
1243           rc, rsp = self.cal.get_virtual_link(self._acct, rsp)
1244           self.assertEqual(rc, RwStatus.SUCCESS)
1245           self.assertEqual(rsp.virtual_link_id, vlink_id)
1246           vlink_list.append(vlink_id)
1247
1248           # Now create VDU
1249           vdu_req = self._get_vol_vdu_request_info(vlink_list)
1250           logger.info("################################### ")
1251           logger.info("Openstack-CAL-Test: Test Create VDU API (w/ volumes) ")
1252
1253           rc, rsp = self.cal.create_vdu(self._acct, vdu_req)
1254           logger.debug("Openstack-CAL-Test: rc %s rsp %s" % (rc, rsp))
1255           self.assertEqual(rc.status, RwStatus.SUCCESS)
1256           logger.info("Openstack-CAL-Test: Created vdu with Id: %s" %rsp)
1257
1258           test_vdu_id = rsp
1259
1260           ## Check if VDU get is successful
1261           rc, rsp = self.cal.get_vdu(self._acct, test_vdu_id)
1262           logger.debug("Get VDU response %s", rsp)
1263           self.assertEqual(rsp.vdu_id, test_vdu_id)
1264
1265           ### Wait until vdu_state is active
1266           logger.debug("Waiting 10 secs")
1267           time.sleep(10)
1268           #{'name': 'dp0vhost7', 'connection_point_id': 'dp0vhost7', 'state': 'active', 'virtual_link_id': 'rift.cal.virtual_link', 'ip_address': '192.168.100.6'}
1269           vdu_state = 'inactive'
1270           cp_state = 'inactive'
1271           for i in range(5):
1272               rc, rsp = self.cal.get_vdu(self._acct, test_vdu_id)
1273               self.assertEqual(rc, RwStatus.SUCCESS)
1274               logger.info("Openstack-CAL-Test: VDU with id : %s. Reached State :  %s, mgmt ip %s" %(test_vdu_id, rsp.state, rsp.management_ip))
1275               if (rsp.state == 'active') and ('management_ip' in rsp) and ('public_ip' in rsp):
1276                   vdu_state = 'active'
1277                   #'connection_points': [{'name': 'dp0vhost7', 'connection_point_id': 'dp0vhost7', 'state': 'active', 'virtual_link_id': 'rift.cal.virtual_link', 'ip_address': '192.168.100.6'}]
1278                   for cp in rsp.connection_points:
1279                       logger.info("Openstack-CAL-Test: VDU with id : %s. Reached State :  %s CP state %s" %(test_vdu_id, rsp.state, cp))
1280                       if vdu_state == 'active' and cp.ip_address is not None :
1281                           cp_state = 'active'
1282                           break
1283               logger.debug("Waiting another 5 secs")
1284               time.sleep(5)
1285
1286           self.assertEqual(rc, RwStatus.SUCCESS)
1287           self.assertEqual(rsp.state, 'active')
1288           self.assertEqual(vdu_state, 'active')
1289           self.assertEqual(cp_state, 'active')
1290           logger.info("Openstack-CAL-Test: VDU with id : %s reached expected state  : %s IP: %s" %(test_vdu_id, rsp.state, rsp.management_ip))
1291           logger.info("Openstack-CAL-Test: VDUInfo: %s" %(rsp))
1292           logger.info("Waiting for 30 secs before deletion")
1293           time.sleep(30)
1294
1295           ### Check vdu list as well
1296           rc, rsp = self.cal.get_vdu_list(self._acct)
1297           self.assertEqual(rc, RwStatus.SUCCESS)
1298           found = False
1299           logger.debug("Get VDU response %s", rsp)
1300           for vdu in rsp.vdu_info_list:
1301               if vdu.vdu_id == test_vdu_id:
1302                  found = True
1303           self.assertEqual(found, True)
1304           logger.info("Openstack-CAL-Test: Passed VDU list" )
1305
1306 class VmData(object):
1307     """A convenience class that provides all the stats and EPA Attributes
1308     from the VM provided
1309     """
1310     def __init__(self, host, mgmt_ip):
1311         """
1312         Args:
1313             host (str): host name.
1314             mgmt_ip (str): The IP of the newly created VM.
1315         """
1316         # Sleep for 20s to ensure the VM is UP and ready to run commands
1317         time.sleep(20)
1318         logger.info("Connecting to host: {} and IP: {}".format(host, mgmt_ip))
1319         self.client = paramiko.SSHClient()
1320         self.client.set_missing_host_key_policy(paramiko.WarningPolicy())
1321         self.client.connect(host)
1322         self.ip = mgmt_ip
1323
1324         # Get all data from the newly created VM.
1325         self._data = self._get_data()
1326         self._page_size = self._exec_and_clean("getconf PAGE_SIZE")
1327         self._disk_space = self._exec_and_clean(
1328                 "df -kh --output=size /",
1329                 line_no=1)
1330         self._pci_data = self._exec('lspci -m | grep "10-Gigabit"')
1331
1332     def _get_data(self,):
1333         """Runs the command and store the output in a python dict.
1334
1335         Returns:
1336             dict: Containing all key => value pairs.
1337         """
1338         content = {}
1339         cmds = ["lscpu", 'less /proc/meminfo']
1340         for cmd in cmds:
1341             ssh_out = self._exec(cmd)
1342             content.update(self._convert_to_dict(ssh_out))
1343         return content
1344
1345     def _exec_and_clean(self, cmd, line_no=0):
1346         """A convenience method to run a command and extract the specified line
1347         number.
1348
1349         Args:
1350             cmd (str): Command to execute
1351             line_no (int, optional): Default to 0, extracts the first line.
1352
1353         Returns:
1354             str: line_no of the output of the command.
1355         """
1356         output = self._exec(cmd)[line_no]
1357         output = ' '.join(output.split())
1358         return output.strip()
1359
1360     def _exec(self, cmd):
1361         """Thin wrapper that runs the command and returns the stdout data
1362
1363         Args:
1364             cmd (str): Command to execute.
1365
1366         Returns:
1367             list: Contains the command output.
1368         """
1369         _, ssh_out, _ = self.client.exec_command(
1370                 "/usr/rift/bin/ssh_root {} {}".format(self.ip,
1371                                                       cmd))
1372         return ssh_out.readlines()
1373
1374     def _convert_to_dict(self, content):
1375         """convenience method that cleans and stores the line into dict.
1376         data is split based on ":" or " ".
1377
1378         Args:
1379             content (list): A list containing the stdout.
1380
1381         Returns:
1382             dict: containing stat attribute => value.
1383         """
1384         flattened = {}
1385         for line in content:
1386             line = ' '.join(line.split())
1387             if ":" in line:
1388                 key, value = line.split(":")
1389             else:
1390                 key, value = line.split(" ")
1391             key, value = key.strip(), value.strip()
1392             flattened[key] = value
1393         return flattened
1394
1395     @property
1396     def disk(self):
1397         disk = self._disk_space.replace("G", "")
1398         return int(disk)
1399
1400     @property
1401     def numa_node_count(self):
1402         numa_cores = self._data['NUMA node(s)']
1403         numa_cores = int(numa_cores)
1404         return numa_cores
1405
1406     @property
1407     def vcpus(self):
1408         cores = int(self._data['CPU(s)'])
1409         return cores
1410
1411     @property
1412     def cpu_threads(self):
1413         threads = int(self._data['Thread(s) per core'])
1414         return threads
1415
1416     @property
1417     def memory(self):
1418         memory = self._data['MemTotal']
1419         memory = int(memory.replace("kB", ""))/1000/1000
1420         return int(memory)
1421
1422     @property
1423     def memory_page_size(self):
1424         return self._page_size
1425
1426     @property
1427     def pci_passthrough_device_list(self):
1428         return self._pci_data
1429
1430
1431 if __name__ == "__main__":
1432     #logging.basicConfig(level=logging.DEBUG)
1433     logger.setLevel(logging.DEBUG)
1434     unittest.main()