-#
+#
# Copyright 2016 RIFT.IO Inc
#
# Licensed under the Apache License, Version 2.0 (the "License");
import time
import unittest
import hashlib
-
import novaclient.exceptions as nova_exception
import paramiko
import rw_peas
from gi.repository import RwcalYang
from gi.repository.RwTypes import RwStatus
-from rift.rwcal.openstack.openstack_drv import KeystoneDriver, NovaDriver
+from rift.rwcal.openstack.openstack_drv import KeystoneDriver, NovaDriver, KeystoneDriverV3, KeystoneDriverV2
logger = logging.getLogger('rwcal-openstack')
+PING_USERDATA = '''
+#cloud-config
+password: fedora
+chpasswd: { expire: False }
+ssh_pwauth: True
+'''
+
#
-# Important information about openstack installation. This needs to be manually verified
+# Important information about openstack installation. This needs to be manually verified
#
openstack_info = {
'username' : 'pluto',
'password' : 'mypasswd',
- 'auth_url' : 'http://10.66.4.14:5000/v3/',
+ 'auth_url' : 'http://10.66.4.17:5000/v3/',
'project_name' : 'demo',
'mgmt_network' : 'private',
'reserved_flavor' : 'm1.medium',
- 'reserved_image' : 'rift-root-latest.qcow2',
+ 'reserved_image' : 'Fedora-x86_64-20-20131211.1-sda-ping.qcow2',
+ 'physical_network' : None,
+ 'network_type' : None,
+ 'segmentation_id' : None,
+ 'user_domain_name' : 'default',
+ 'project_domain_name': 'default'
+ }
+
+openstack_V3_info = {
+ 'username' : 'riftdev_admin',
+ 'password' : 'mypasswd',
+ 'auth_url' : 'http://10.68.0.11:5000/v3/',
+ 'project_name' : 'demov3',
+ 'mgmt_network' : 'center',
'physical_network' : None,
'network_type' : None,
- 'segmentation_id' : None
+ 'segmentation_id' : None,
+ 'user_domain_name' : 'riftdev',
+ 'project_domain_name': 'riftdev'
}
"""
Creates an object for class RwcalYang.CloudAccount()
"""
- account = RwcalYang.CloudAccount()
- account.account_type = "openstack"
- account.openstack.key = openstack_info['username']
- account.openstack.secret = openstack_info['password']
- account.openstack.auth_url = openstack_info['auth_url']
- account.openstack.tenant = openstack_info['project_name']
- account.openstack.mgmt_network = openstack_info['mgmt_network']
+ account = RwcalYang.CloudAccount()
+ account.name = "Gruntxx"
+ account.account_type = "openstack"
+ account.openstack.key = openstack_info['username']
+ account.openstack.secret = openstack_info['password']
+ account.openstack.auth_url = openstack_info['auth_url']
+ account.openstack.tenant = openstack_info['project_name']
+ account.openstack.mgmt_network = openstack_info['mgmt_network']
+ account.openstack.user_domain = openstack_info['user_domain_name']
+ account.openstack.project_domain = openstack_info['project_domain_name']
return account
def get_cal_plugin():
logger.error("ERROR:Cal plugin instantiation failed. Aborting tests")
else:
logger.info("Openstack Cal plugin successfully instantiated")
- return cal
+ return cal
class OpenStackTest(unittest.TestCase):
HostTrust = "trusted"
PCIPassThroughAlias = "PCI_10G_ALIAS"
SEG_ID = openstack_info['segmentation_id']
-
+
def setUp(self):
"""
Assumption:
logger.info("Openstack-CAL-Test: setUp")
self.cal = get_cal_plugin()
logger.info("Openstack-CAL-Test: setUpEND")
-
+
# First check for VM Flavor and Image and get the corresponding IDs
rc, rs = self.cal.get_flavor_list(self._acct)
self.assertEqual(rc, RwStatus.SUCCESS)
rc, rs = self.cal.get_network_list(self._acct)
self.assertEqual(rc, RwStatus.SUCCESS)
- networks = [ network for network in rs.networkinfo_list if (network.network_name == 'rift.cal.unittest.network' or network.network_name == 'rift.cal.virtual_link') ]
+ 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) ) ]
for network in networks:
+ logger.debug("Openstack-CAL-Test: Deleting old VL %s", network.network_id)
self.cal.delete_virtual_link(self._acct, network.network_id)
-
+
def tearDown(self):
logger.info("Openstack-CAL-Test: tearDown")
-
+
def _md5(fname, blksize=1048576):
hash_md5 = hashlib.md5()
hash_md5.update(chunk)
return hash_md5.hexdigest()
- @unittest.skip("Skipping test_list_flavors")
+ @unittest.skip("Skipping test_list_flavors")
def test_list_flavor(self):
"""
List existing flavors from openstack installation
rc, flv = self.cal.get_flavor(self._acct, flavor.id)
self.assertEqual(rc, RwStatus.SUCCESS)
self.assertEqual(flavor.id, flv.id)
-
- @unittest.skip("Skipping test_list_images")
+
+ @unittest.skip("Skipping test_list_images")
def test_list_images(self):
"""
List existing images from openstack installation
# rc, img = self.cal.get_image(self._acct, image.id)
# self.assertEqual(rc, RwStatus.SUCCESS)
# self.assertEqual(image.id, img.id)
-
- @unittest.skip("Skipping test_list_vms")
+
+ @unittest.skip("Skipping test_list_vms")
def test_list_vms(self):
"""
List existing VMs from openstack installation
for vm in rsp.vminfo_list:
rc, server = self.cal.get_vm(self._acct, vm.vm_id)
self.assertEqual(vm.vm_id, server.vm_id)
-
- @unittest.skip("Skipping test_list_networks")
+
+ @unittest.skip("Skipping test_list_networks")
def test_list_networks(self):
"""
List existing Network from openstack installation
for network in rsp.networkinfo_list:
rc, net = self.cal.get_network(self._acct, network.network_id)
self.assertEqual(network.network_id, net.network_id)
-
- @unittest.skip("Skipping test_list_ports")
+
+ @unittest.skip("Skipping test_list_ports")
def test_list_ports(self):
"""
List existing Ports from openstack installation
else:
time.sleep(2) # Sleep for a second
return rs
-
- @unittest.skip("Skipping test_create_delete_image")
+
+ @unittest.skip("Skipping test_create_delete_image")
def test_create_delete_image(self):
"""
Create/Query/Delete a new image in openstack installation
flavor = RwcalYang.FlavorInfoItem()
flavor.name = 'rift.cal.unittest.flavor'
flavor.vm_flavor.memory_mb = 16384 # 16GB
- flavor.vm_flavor.vcpu_count = 4
+ flavor.vm_flavor.vcpu_count = 4
flavor.vm_flavor.storage_gb = 40 # 40GB
flavor.guest_epa.mempage_size = OpenStackTest.MemoryPageSize
flavor.guest_epa.cpu_pinning_policy = OpenStackTest.CpuPolicy
node = flavor.guest_epa.numa_node_policy.node.add()
node.id = i
if i == 0:
- node.vcpu = [0,1]
+ vcpu = node.vcpu.add()
+ vcpu.id = 0
+ vcpu = node.vcpu.add()
+ vcpu.id = 1
elif i == 1:
- node.vcpu = [2,3]
+ vcpu = node.vcpu.add()
+ vcpu.id = 2
+ vcpu = node.vcpu.add()
+ vcpu.id = 3
node.memory_mb = 8196
dev = flavor.guest_epa.pcie_device.add()
dev.device_id = OpenStackTest.PCIPassThroughAlias
dev.count = 1
return flavor
-
- @unittest.skip("Skipping test_create_delete_flavor")
+
+ @unittest.skip("Skipping test_create_delete_flavor")
def test_create_delete_flavor(self):
"""
Create/Query/Delete a new flavor in openstack installation
if flavor_list:
rc = self.cal.delete_flavor(self._acct, flavor_list[0].id)
self.assertEqual(rc, RwStatus.SUCCESS)
-
+
flavor = self._get_flavor_info_request()
rc, flavor_id = self.cal.create_flavor(self._acct, flavor)
self.assertEqual(rc, RwStatus.SUCCESS)
-
+
logger.info("Openstack-CAL-Test: Created new flavor with flavor_id : %s" %(flavor_id))
rc, rs = self.cal.get_flavor(self._acct, flavor_id)
self.assertEqual(rc, RwStatus.SUCCESS)
def _check_vm_state(self, vm_id, expected_state):
"""
- Wait until VM reaches particular state (expected_state).
+ Wait until VM reaches particular state (expected_state).
"""
# Wait while VM goes to required state
if port_list:
for port_id in port_list:
port = vm.port_list.add()
- port.port_id = port_id
+ port.port_id = port_id
rc, vm_id = self.cal.create_vm(self._acct, vm)
self.assertEqual(rc, RwStatus.SUCCESS)
vm_list = [vm for vm in rs.vminfo_list if vm.vm_id == vm_id]
if not len(vm_list):
break
-
+
rc, rs = self.cal.get_vm_list(self._acct)
self.assertEqual(rc, RwStatus.SUCCESS)
vm_list = [vm for vm in rs.vminfo_list if vm.vm_id == vm_id]
self.assertEqual(rc, RwStatus.SUCCESS)
### Ensure that VM state is SHUTOFF
self._check_vm_state(vm_id, 'SHUTOFF')
-
-
+
+
def _start_vm(self, vm_id):
"""
Starts VM and performs validity checks
### Ensure that VM state is ACTIVE
self._check_vm_state(vm_id, 'ACTIVE')
-
+
def _reboot_vm(self, vm_id):
"""
Reboot VM and perform validity checks
logger.info("Openstack-CAL-Test: Starting VM(EPA) create/delete test")
flavor = self._get_flavor_info_request()
-
+
rc, flavor_id = self.cal.do_create_flavor(self._acct, flavor)
self.assertEqual(rc, RwStatus.SUCCESS)
flavor.id = flavor_id
openstack_info['username'],
openstack_info['password'],
openstack_info['auth_url'],
+ None,
openstack_info['project_name'])
# Get hold of the client instance need for Token Manager
client = drv._get_keystone_connection()
flavors = nova.flavor_list()
self.assertTrue(len(flavors) > 1)
- @unittest.skip("Skipping test_vm_operations")
+ def test_v3_Keystone(self):
+ # Keystone v3 authentication
+ auth_exp = False
+ try:
+ drv = KeystoneDriverV3(openstack_V3_info['username'],
+ openstack_V3_info['password'],
+ openstack_V3_info['auth_url'],
+ openstack_V3_info['project_name'],
+ None,
+ openstack_V3_info['user_domain_name'],
+ openstack_V3_info['project_domain_name'])
+ client = drv._get_keystone_connection()
+ except Exception:
+ auth_exp = True
+ self.assertFalse(auth_exp)
+
+ # Incorrect domain being to passed to v3 Keystone API
+ auth_exp = False
+ try:
+ drv = KeystoneDriverV3(openstack_V3_info['username'],
+ openstack_V3_info['password'],
+ openstack_V3_info['auth_url'],
+ openstack_V3_info['project_name'],
+ None,
+ "DummyDom",
+ openstack_V3_info['project_domain_name'])
+ client = drv._get_keystone_connection()
+ except Exception:
+ auth_exp = True
+ self.assertTrue(auth_exp)
+
+ # Keystone v3 authentication-Backward compatabilty test
+ auth_exp = False
+ try:
+ drv = KeystoneDriverV3(openstack_info['username'],
+ openstack_info['password'],
+ openstack_info['auth_url'],
+ openstack_info['project_name'],
+ None,
+ openstack_info['user_domain_name'],
+ openstack_info['project_domain_name'])
+ client = drv._get_keystone_connection()
+ except Exception:
+ auth_exp = True
+ self.assertFalse(auth_exp)
+
+ # Keystone v3 authentication-Backward compatabilty
+ auth_exp = False
+ try:
+ drv = KeystoneDriverV3(openstack_info['username'],
+ openstack_info['password'],
+ openstack_info['auth_url'],
+ openstack_info['project_name'],
+ None,
+ None,
+ None)
+ client = drv._get_keystone_connection()
+ except Exception:
+ auth_exp = True
+ self.assertFalse(auth_exp)
+
+ # Keystone v2 authentication
+ auth_exp = False
+ try:
+ drv2 = KeystoneDriverV2(
+ openstack_info['username'],
+ openstack_info['password'],
+ 'http://10.66.4.17:5000/v2.0',
+ openstack_info['project_name'],
+ None)
+ client = drv2._get_keystone_connection()
+ except Exception:
+ auth_exp = True
+ self.assertFalse(auth_exp)
+
+ @unittest.skip("Skipping test_vm_operations")
def test_vm_operations(self):
"""
Primary goal: Create/Query/Delete VM in openstack installation.
### Delete the VM
self._delete_vm(vm_id)
-
+
def _get_network_info_request(self):
"""
Returns request object of type RwcalYang.NetworkInfoItem
logger.info("Openstack-CAL-Test: Deleting a network with id : %s. " %(net_id))
rc = self.cal.delete_network(self._acct, net_id)
self.assertEqual(rc, RwStatus.SUCCESS)
-
+
# Verify that network is no longer available via get_network_list API
rc, rs = self.cal.get_network_list(self._acct)
self.assertEqual(rc, RwStatus.SUCCESS)
network_info = [ network for network in rs.networkinfo_list if network.network_id == net_id ]
self.assertEqual(len(network_info), 0)
logger.info("Openstack-CAL-Test: Successfully deleted Network with id : %s" %(net_id))
-
-
- @unittest.skip("Skipping test_network_operations")
+
+
+ @unittest.skip("Skipping test_network_operations")
def test_network_operations(self):
"""
Create/Delete Networks
### Delete Port
self.cal.delete_port(self._acct, port_id)
-
+
rc, rs = self.cal.get_port_list(self._acct)
self.assertEqual(rc, RwStatus.SUCCESS)
port_list = [ port for port in rs.portinfo_list if port.port_id == port_id ]
self.assertEqual(rc, RwStatus.SUCCESS)
self.assertEqual(rs.port_state, expected_state)
logger.info("Openstack-CAL-Test: Port with port_id : %s reached expected state : %s" %(port_id, rs.port_state))
-
+
@unittest.skip("Skipping test_port_operations_with_vm")
def test_port_operations_with_vm(self):
"""
### Delete VM
self._delete_vm(vm_id)
-
+
### Delete Port
self._delete_port(port_id)
### Delete VM
self._delete_vm(vm_id)
-
+
### Delete Port
self._delete_port(port_id)
vlink.provider_network.segmentation_id = OpenStackTest.SEG_ID
OpenStackTest.SEG_ID += 1
return vlink
-
+
def _get_vdu_request_info(self, virtual_link_id):
"""
Returns object of type RwcalYang.VDUInitParams
vdu.node_id = OpenStackTest.NodeID
vdu.image_id = self._image.id
vdu.flavor_id = self._flavor.id
- vdu.vdu_init.userdata = ''
+ vdu.vdu_init.userdata = PING_USERDATA
vdu.allocate_public_address = True
+ meta1 = vdu.supplemental_boot_data.custom_meta_data.add()
+ meta1.name = "EMS_IP"
+ meta1.data_type = "STRING"
+ meta1.value = "10.5.6.6"
+ #meta2 = vdu.supplemental_boot_data.custom_meta_data.add()
+ #meta2.name = "Cluster_data"
+ #meta2.data_type = "JSON"
+ #meta2.value = '''{ "cluster_id": "12" , "vnfc_id": "112" }'''
+ #vdu.supplemental_boot_data.boot_data_drive = True
+ customfile1 = vdu.supplemental_boot_data.config_file.add()
+ customfile1.source = "abcdef124"
+ customfile1.dest = "/tmp/tempfile.txt"
+ customfile2 = vdu.supplemental_boot_data.config_file.add()
+ customfile2.source = "123456"
+ customfile2.dest = "/tmp/tempfile2.txt"
c1 = vdu.connection_points.add()
c1.name = "c_point1"
c1.virtual_link_id = virtual_link_id
c1 = vdu.connection_points_add.add()
c1.name = "c_modify1"
c1.virtual_link_id = virtual_link_id
-
- return vdu
-
- #@unittest.skip("Skipping test_create_delete_virtual_link_and_vdu")
+
+ return vdu
+
+ @unittest.skip("Skipping test_create_delete_virtual_link_and_vdu")
def test_create_delete_virtual_link_and_vdu(self):
"""
Test to create VDU
vlink_req = self._get_virtual_link_request_info()
rc, rsp = self.cal.create_virtual_link(self._acct, vlink_req)
- self.assertEqual(rc, RwStatus.SUCCESS)
+ self.assertEqual(rc.status, RwStatus.SUCCESS)
logger.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp)
vlink_id = rsp
-
+
#Check if virtual_link create is successful
rc, rsp = self.cal.get_virtual_link(self._acct, rsp)
self.assertEqual(rc, RwStatus.SUCCESS)
logger.info("Openstack-CAL-Test: Test Create VDU API")
rc, rsp = self.cal.create_vdu(self._acct, vdu_req)
- self.assertEqual(rc, RwStatus.SUCCESS)
+ self.assertEqual(rc.status, RwStatus.SUCCESS)
logger.info("Openstack-CAL-Test: Created vdu with Id: %s" %rsp)
vdu_id = rsp
self.assertEqual(rs.state, 'active')
logger.info("Openstack-CAL-Test: VDU with id : %s reached expected state : %s" %(vdu_id, rs.state))
logger.info("Openstack-CAL-Test: VDUInfo: %s" %(rs))
-
+
vlink_req = self._get_virtual_link_request_info()
### Create another virtual_link
rc, rsp = self.cal.create_virtual_link(self._acct, vlink_req)
- self.assertEqual(rc, RwStatus.SUCCESS)
+ self.assertEqual(rc.status, RwStatus.SUCCESS)
logger.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp)
vlink_id2= rsp
logger.info("Openstack-CAL-Test: VDU/Virtual Link create-delete test successfully completed")
+ def _get_vol_vdu_request_info(self, vlink_list):
+ """
+ Returns object of type RwcalYang.VDUInitParams
+ """
+ vdu = RwcalYang.VDUInitParams()
+ vdu.name = "cal_vdu"
+ vdu.flavor_id = self._flavor.id
+ vdu.allocate_public_address = True
+ ctr = 0
+ for vl in vlink_list:
+ c1 = vdu.connection_points.add()
+ c1.name = "c_point" + str(ctr)
+ ctr += 1
+ c1.virtual_link_id = vl
+ c1.type_yang = 'VIRTIO'
+
+ vol0 = vdu.volumes.add()
+ vol0.name = "vda"
+ vol0.image = openstack_info['reserved_image']
+ vol0.size = 10
+ vol0.boot_priority = 0
+ vol0.device_type = "disk"
+ meta1 = vol0.custom_meta_data.add()
+ meta1.name = "fs_type"
+ meta1.data_type = "STRING"
+ meta1.value = "ext4"
+
+ return vdu
+
+ #@unittest.skip("Skipping test_create_vol_vdu")
+ def test_create_vol_vdu(self):
+ """
+ Test to create VDU with mgmt port using Volumes
+ """
+ logger.info("Openstack-CAL-Test: Test Create Virtual Link API")
+ vlink_list = []
+ vlink = RwcalYang.VirtualLinkReqParams()
+ vlink.name = 'rift.cal.virtual_link'
+ vlink.subnet = '11.0.1.0/24'
+
+ rc, rsp = self.cal.create_virtual_link(self._acct, vlink)
+ self.assertEqual(rc.status, RwStatus.SUCCESS)
+ logger.info("Openstack-CAL-Test: Created virtual_link with Id: %s" %rsp)
+ vlink_id = rsp
+
+ #Check if virtual_link create is successful
+ rc, rsp = self.cal.get_virtual_link(self._acct, rsp)
+ self.assertEqual(rc, RwStatus.SUCCESS)
+ self.assertEqual(rsp.virtual_link_id, vlink_id)
+ vlink_list.append(vlink_id)
+
+ # Now create VDU
+ vdu_req = self._get_vol_vdu_request_info(vlink_list)
+ logger.info("################################### ")
+ logger.info("Openstack-CAL-Test: Test Create VDU API (w/ volumes) ")
+
+ rc, rsp = self.cal.create_vdu(self._acct, vdu_req)
+ logger.debug("Openstack-CAL-Test: rc %s rsp %s" % (rc, rsp))
+ self.assertEqual(rc.status, RwStatus.SUCCESS)
+ logger.info("Openstack-CAL-Test: Created vdu with Id: %s" %rsp)
+
+ test_vdu_id = rsp
+
+ ## Check if VDU get is successful
+ rc, rsp = self.cal.get_vdu(self._acct, test_vdu_id)
+ logger.debug("Get VDU response %s", rsp)
+ self.assertEqual(rsp.vdu_id, test_vdu_id)
+
+ ### Wait until vdu_state is active
+ logger.debug("Waiting 10 secs")
+ time.sleep(10)
+ #{'name': 'dp0vhost7', 'connection_point_id': 'dp0vhost7', 'state': 'active', 'virtual_link_id': 'rift.cal.virtual_link', 'ip_address': '192.168.100.6'}
+ vdu_state = 'inactive'
+ cp_state = 'inactive'
+ for i in range(5):
+ rc, rsp = self.cal.get_vdu(self._acct, test_vdu_id)
+ self.assertEqual(rc, RwStatus.SUCCESS)
+ logger.info("Openstack-CAL-Test: VDU with id : %s. Reached State : %s, mgmt ip %s" %(test_vdu_id, rsp.state, rsp.management_ip))
+ if (rsp.state == 'active') and ('management_ip' in rsp) and ('public_ip' in rsp):
+ vdu_state = 'active'
+ #'connection_points': [{'name': 'dp0vhost7', 'connection_point_id': 'dp0vhost7', 'state': 'active', 'virtual_link_id': 'rift.cal.virtual_link', 'ip_address': '192.168.100.6'}]
+ for cp in rsp.connection_points:
+ logger.info("Openstack-CAL-Test: VDU with id : %s. Reached State : %s CP state %s" %(test_vdu_id, rsp.state, cp))
+ if vdu_state == 'active' and cp.ip_address is not None :
+ cp_state = 'active'
+ break
+ logger.debug("Waiting another 5 secs")
+ time.sleep(5)
+
+ self.assertEqual(rc, RwStatus.SUCCESS)
+ self.assertEqual(rsp.state, 'active')
+ self.assertEqual(vdu_state, 'active')
+ self.assertEqual(cp_state, 'active')
+ logger.info("Openstack-CAL-Test: VDU with id : %s reached expected state : %s IP: %s" %(test_vdu_id, rsp.state, rsp.management_ip))
+ logger.info("Openstack-CAL-Test: VDUInfo: %s" %(rsp))
+ logger.info("Waiting for 30 secs before deletion")
+ time.sleep(30)
+
+ ### Check vdu list as well
+ rc, rsp = self.cal.get_vdu_list(self._acct)
+ self.assertEqual(rc, RwStatus.SUCCESS)
+ found = False
+ logger.debug("Get VDU response %s", rsp)
+ for vdu in rsp.vdu_info_list:
+ if vdu.vdu_id == test_vdu_id:
+ found = True
+ self.assertEqual(found, True)
+ logger.info("Openstack-CAL-Test: Passed VDU list" )
class VmData(object):
"""A convenience class that provides all the stats and EPA Attributes
if __name__ == "__main__":
- logging.basicConfig(level=logging.INFO)
+ #logging.basicConfig(level=logging.DEBUG)
+ logger.setLevel(logging.DEBUG)
unittest.main()
projects / osm / SO.git / blobdiff