mirror of
https://github.com/apache/cloudstack.git
synced 2025-11-03 04:12:31 +01:00
CLOUDSTACK-9322 : Marvin tests for Internal Lb with Nuage VSP
This commit is contained in:
Prashanth Manthena
Nick Livens
parent
741e88833f
commit
de86c0cb17
@ -15,43 +15,36 @@
|
||||
# specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
""" Custom base class for NuageVsp SDN Plugin specific Marvin tests
|
||||
""" Custom base class for Nuage VSP SDN plugin specific Marvin tests
|
||||
"""
|
||||
# Import Local Modules
|
||||
from marvin.cloudstackTestCase import cloudstackTestCase, unittest
|
||||
from marvin.lib.base import (NetworkServiceProvider,
|
||||
ServiceOffering,
|
||||
NetworkOffering,
|
||||
Network,
|
||||
Router,
|
||||
Nuage,
|
||||
VPC,
|
||||
VpcOffering,
|
||||
PublicIPAddress,
|
||||
VirtualMachine,
|
||||
StaticNATRule,
|
||||
NetworkACLList,
|
||||
NetworkACL,
|
||||
from marvin.lib.base import (EgressFireWallRule,
|
||||
FireWallRule,
|
||||
EgressFireWallRule,
|
||||
Host)
|
||||
from marvin.lib.common import (get_zone,
|
||||
get_domain,
|
||||
Hypervisor,
|
||||
Network,
|
||||
NetworkACL,
|
||||
NetworkACLList,
|
||||
NetworkOffering,
|
||||
NetworkServiceProvider,
|
||||
Nuage,
|
||||
PhysicalNetwork,
|
||||
PublicIPAddress,
|
||||
Router,
|
||||
ServiceOffering,
|
||||
StaticNATRule,
|
||||
VirtualMachine,
|
||||
VPC,
|
||||
VpcOffering)
|
||||
from marvin.lib.common import (get_domain,
|
||||
get_template,
|
||||
list_templates,
|
||||
wait_for_cleanup)
|
||||
get_zone)
|
||||
from marvin.lib.utils import cleanup_resources
|
||||
from marvin.cloudstackAPI import (listPhysicalNetworks,
|
||||
updateConfiguration,
|
||||
updateTemplate,
|
||||
listConfigurations,
|
||||
listHypervisors,
|
||||
stopRouter,
|
||||
startRouter)
|
||||
from marvin.cloudstackAPI import restartVPC
|
||||
# Import System Modules
|
||||
import socket
|
||||
import importlib
|
||||
import logging
|
||||
import socket
|
||||
|
||||
|
||||
class nuageTestCase(cloudstackTestCase):
|
||||
@ -84,42 +77,36 @@ class nuageTestCase(cloudstackTestCase):
|
||||
)
|
||||
cls._cleanup = [cls.service_offering]
|
||||
|
||||
# Get configured Nuage Vsp device details
|
||||
# Get configured Nuage VSP device details
|
||||
try:
|
||||
resp = listPhysicalNetworks.listPhysicalNetworksCmd()
|
||||
resp.zoneid = cls.zone.id
|
||||
physical_networks = cls.api_client.listPhysicalNetworks(resp)
|
||||
physical_networks = PhysicalNetwork.list(cls.api_client, zoneid=cls.zone.id)
|
||||
for pn in physical_networks:
|
||||
if pn.isolationmethods == 'VSP':
|
||||
if pn.isolationmethods == "VSP":
|
||||
cls.vsp_physical_network = pn
|
||||
break
|
||||
cls.nuage_vsp_device = Nuage.list(cls.api_client,
|
||||
physicalnetworkid=cls.vsp_physical_network.id
|
||||
)[0]
|
||||
pns = cls.config.zones[0].physical_networks
|
||||
providers = filter(lambda physical_network: 'VSP' in physical_network.isolationmethods, pns)[0].providers
|
||||
devices = filter(lambda provider: provider.name == 'NuageVsp', providers)[0].devices
|
||||
providers = filter(lambda physical_network: "VSP" in physical_network.isolationmethods, pns)[0].providers
|
||||
devices = filter(lambda provider: provider.name == "NuageVsp", providers)[0].devices
|
||||
cls.nuage_vsp_device.username = devices[0].username
|
||||
cls.nuage_vsp_device.password = devices[0].password
|
||||
listConfigurationsCmd = listConfigurations.listConfigurationsCmd()
|
||||
listConfigurationsCmd.name = "nuagevsp.cms.id"
|
||||
listConfigurationsCmd.scopename = "global"
|
||||
cs_config_dict = cls.api_client.listConfigurations(listConfigurationsCmd)
|
||||
cls.cms_id = str(cs_config_dict[0].value).split(":")[1]
|
||||
cls.cms_id = cls.nuage_vsp_device.cmsid
|
||||
except Exception as e:
|
||||
cls.tearDownClass()
|
||||
raise unittest.SkipTest("Warning: Couldn't get configured Nuage Vsp device details: %s" % e)
|
||||
raise unittest.SkipTest("Warning: Couldn't get configured Nuage VSP device details: %s" % e)
|
||||
|
||||
# Check if the host hypervisor type is simulator
|
||||
resp = listHypervisors.listHypervisorsCmd()
|
||||
resp.zoneid = cls.zone.id
|
||||
cls.isSimulator = cls.api_client.listHypervisors(resp)[0].name == 'Simulator'
|
||||
cls.isSimulator = Hypervisor.list(cls.api_client, zoneid=cls.zone.id)[0].name == "Simulator"
|
||||
|
||||
# VSD is a Python SDK for Nuage Vsp
|
||||
# VSD is a programmable policy and analytics engine of Nuage VSP SDN platform
|
||||
# vspk is a Python SDK for Nuage VSP's VSD
|
||||
# cms_vspk_wrapper is a library that wraps vspk package
|
||||
try:
|
||||
vspk_module = "vspk." + cls.nuage_vsp_device.apiversion if int(cls.nuage_vsp_device.apiversion[1]) >= 4 \
|
||||
else "vspk.vsdk." + cls.nuage_vsp_device.apiversion
|
||||
vsdk = importlib.import_module(vspk_module)
|
||||
cls.vsdk = importlib.import_module(vspk_module)
|
||||
vspk_utils_module = "vspk.utils" if int(cls.nuage_vsp_device.apiversion[1]) >= 4 \
|
||||
else "vspk.vsdk." + cls.nuage_vsp_device.apiversion + ".utils"
|
||||
vsdk_utils = importlib.import_module(vspk_utils_module)
|
||||
@ -129,12 +116,12 @@ class nuageTestCase(cloudstackTestCase):
|
||||
raise unittest.SkipTest("vspk (and/or) cms_vspk_wrapper import failure")
|
||||
|
||||
# Configure VSD session
|
||||
cls._session = vsdk.NUVSDSession(username=cls.nuage_vsp_device.username,
|
||||
password=cls.nuage_vsp_device.password,
|
||||
enterprise="csp", api_url="https://%s:%d" %
|
||||
(cls.nuage_vsp_device.hostname,
|
||||
cls.nuage_vsp_device.port)
|
||||
)
|
||||
cls._session = cls.vsdk.NUVSDSession(username=cls.nuage_vsp_device.username,
|
||||
password=cls.nuage_vsp_device.password,
|
||||
enterprise="csp", api_url="https://%s:%d" %
|
||||
(cls.nuage_vsp_device.hostname,
|
||||
cls.nuage_vsp_device.port)
|
||||
)
|
||||
cls._session.start()
|
||||
|
||||
# Configure cms_vspk_wrapper session
|
||||
@ -157,7 +144,7 @@ class nuageTestCase(cloudstackTestCase):
|
||||
# Cleanup resources used
|
||||
cleanup_resources(cls.api_client, cls._cleanup)
|
||||
except Exception as e:
|
||||
cls.debug("Warning: Exception during cleanup : %s" % e)
|
||||
cls.debug("Warning: Exception during cleanup: %s" % e)
|
||||
return
|
||||
|
||||
def tearDown(self):
|
||||
@ -176,69 +163,51 @@ class nuageTestCase(cloudstackTestCase):
|
||||
self.debug("Cleanup complete!")
|
||||
return
|
||||
|
||||
def getConfigurationValue(self, name, scope="global"):
|
||||
listConfigurationsCmd = listConfigurations.listConfigurationsCmd()
|
||||
listConfigurationsCmd.name = name
|
||||
listConfigurationsCmd.scopename = scope
|
||||
if scope is "zone":
|
||||
listConfigurationsCmd.zoneid = self.zone.id
|
||||
return self.api_client.listConfigurations(listConfigurationsCmd)
|
||||
|
||||
def setConfigurationValue(self, name, value, scope="global"):
|
||||
cmd = updateConfiguration.updateConfigurationCmd()
|
||||
cmd.name = name
|
||||
cmd.scopename = scope
|
||||
if scope is "zone":
|
||||
cmd.zoneid = self.zone.id
|
||||
cmd.value = value
|
||||
self.api_client.updateConfiguration(cmd)
|
||||
|
||||
def updateTemplate(self, value):
|
||||
self.debug("UPDATE TEMPLATE")
|
||||
cmd = updateTemplate.updateTemplateCmd()
|
||||
cmd.id = self.template.id
|
||||
cmd.passwordenabled = value
|
||||
self.api_client.updateTemplate(cmd)
|
||||
list_template_response = list_templates(self.api_client,
|
||||
templatefilter="all",
|
||||
id=self.template.id
|
||||
)
|
||||
self.template = list_template_response[0]
|
||||
|
||||
# Creates the vpc offering
|
||||
# create_VpcOffering - Creates VPC offering
|
||||
def create_VpcOffering(self, vpc_offering, suffix=None):
|
||||
self.debug('Create VpcOffering')
|
||||
self.debug("Creating VPC offering")
|
||||
if suffix:
|
||||
vpc_offering["name"] = "VPC_OFF-" + str(suffix)
|
||||
vpc_off = VpcOffering.create(self.api_client,
|
||||
vpc_offering
|
||||
)
|
||||
# Enable VPC offering
|
||||
vpc_off.update(self.api_client, state='Enabled')
|
||||
vpc_off.update(self.api_client, state="Enabled")
|
||||
self.cleanup.append(vpc_off)
|
||||
self.debug('Created and Enabled VpcOffering')
|
||||
self.debug("Created and Enabled VPC offering")
|
||||
return vpc_off
|
||||
|
||||
# create_Vpc - Takes the vpc offering as arguments and creates the VPC
|
||||
def create_Vpc(self, vpc_offering, cidr='10.1.1.1/16', cleanup=True):
|
||||
self.debug("Creating a VPC network in the account: %s" % self.account.name)
|
||||
# create_Vpc - Creates VPC with the given VPC offering
|
||||
def create_Vpc(self, vpc_offering, cidr="10.1.1.1/16", cleanup=True):
|
||||
self.debug("Creating a VPC in the account - %s" % self.account.name)
|
||||
self.test_data["vpc"]["name"] = "TestVPC"
|
||||
self.test_data["vpc"]["displaytext"] = "TestVPC"
|
||||
self.test_data["vpc"]["cidr"] = cidr
|
||||
vpc = VPC.create(
|
||||
self.api_client,
|
||||
self.test_data["vpc"],
|
||||
vpcofferingid=vpc_offering.id,
|
||||
zoneid=self.zone.id,
|
||||
account=self.account.name,
|
||||
domainid=self.account.domainid
|
||||
)
|
||||
self.debug("Created VPC with ID: %s" % vpc.id)
|
||||
vpc = VPC.create(self.api_client,
|
||||
self.test_data["vpc"],
|
||||
vpcofferingid=vpc_offering.id,
|
||||
zoneid=self.zone.id,
|
||||
account=self.account.name,
|
||||
domainid=self.account.domainid
|
||||
)
|
||||
self.debug("Created VPC with ID - %s" % vpc.id)
|
||||
if cleanup:
|
||||
self.cleanup.append(vpc)
|
||||
return vpc
|
||||
|
||||
# create_NetworkOffering - Takes the network offering as argument and creates the Network Offering
|
||||
# restart_Vpc - Restarts the given VPC with/without cleanup
|
||||
def restart_Vpc(self, vpc, cleanup=None):
|
||||
self.debug("Restarting VPC with ID - %s" % vpc.id)
|
||||
cmd = restartVPC.restartVPCCmd()
|
||||
cmd.id = vpc.id
|
||||
cmd.cleanup = cleanup
|
||||
cmd.makeredundant = False
|
||||
self.api_client.restartVPC(cmd)
|
||||
self.debug("Restarted VPC with ID - %s" % vpc.id)
|
||||
|
||||
# create_NetworkOffering - Creates Network offering
|
||||
def create_NetworkOffering(self, net_offering, suffix=None, conserve_mode=False):
|
||||
self.debug('Create NetworkOffering')
|
||||
self.debug("Creating Network offering")
|
||||
if suffix:
|
||||
net_offering["name"] = "NET_OFF-" + str(suffix)
|
||||
nw_off = NetworkOffering.create(self.api_client,
|
||||
@ -246,192 +215,78 @@ class nuageTestCase(cloudstackTestCase):
|
||||
conservemode=conserve_mode
|
||||
)
|
||||
# Enable Network offering
|
||||
nw_off.update(self.api_client, state='Enabled')
|
||||
nw_off.update(self.api_client, state="Enabled")
|
||||
self.cleanup.append(nw_off)
|
||||
self.debug('Created and Enabled NetworkOffering')
|
||||
self.debug("Created and Enabled Network offering")
|
||||
return nw_off
|
||||
|
||||
# create_Network - Takes the network offering as argument and nw_key and creates the network
|
||||
def create_Network(self, nw_off, nw_key="network", gateway='10.1.1.1', netmask='255.255.255.0', vpc=None, acl_list=None):
|
||||
if not hasattr(nw_off, "id"):
|
||||
nw_off = self.create_NetworkOffering(nw_off)
|
||||
self.debug('Adding Network=%s' % self.test_data[nw_key])
|
||||
self.test_data[nw_key]["netmask"] = netmask
|
||||
obj_network = Network.create(self.api_client,
|
||||
self.test_data[nw_key],
|
||||
accountid=self.account.name,
|
||||
domainid=self.account.domainid,
|
||||
networkofferingid=nw_off.id,
|
||||
zoneid=self.zone.id,
|
||||
gateway=gateway,
|
||||
vpcid=vpc.id if vpc else self.vpc.id if hasattr(self, "vpc") else None,
|
||||
aclid=acl_list.id if acl_list else None
|
||||
)
|
||||
self.debug("Created network with ID: %s" % obj_network.id)
|
||||
self.cleanup.append(obj_network)
|
||||
return obj_network
|
||||
# create_Network - Creates network with the given Network offering
|
||||
def create_Network(self, nw_off, gateway="10.1.1.1", netmask="255.255.255.0", vpc=None, acl_list=None):
|
||||
self.debug("Creating a network in the account - %s" % self.account.name)
|
||||
self.test_data["network"]["netmask"] = netmask
|
||||
network = Network.create(self.api_client,
|
||||
self.test_data["network"],
|
||||
accountid=self.account.name,
|
||||
domainid=self.account.domainid,
|
||||
networkofferingid=nw_off.id,
|
||||
zoneid=self.zone.id,
|
||||
gateway=gateway,
|
||||
vpcid=vpc.id if vpc else self.vpc.id if hasattr(self, "vpc") else None,
|
||||
aclid=acl_list.id if acl_list else None
|
||||
)
|
||||
self.debug("Created network with ID - %s" % network.id)
|
||||
self.cleanup.append(network)
|
||||
return network
|
||||
|
||||
# upgrade_Network - Upgrades the given network
|
||||
def upgrade_Network(self, nw_off, network):
|
||||
if not hasattr(nw_off, "id"):
|
||||
nw_off = self.create_NetworkOffering(nw_off, network.gateway)
|
||||
self.debug('Update Network=%s' % network)
|
||||
network.update(
|
||||
self.api_client,
|
||||
networkofferingid=nw_off.id,
|
||||
changecidr=False
|
||||
)
|
||||
self.debug("Updated network with ID: %s" % network.id)
|
||||
self.debug("Updating Network with ID - %s" % network.id)
|
||||
network.update(self.api_client,
|
||||
networkofferingid=nw_off.id,
|
||||
changecidr=False
|
||||
)
|
||||
self.debug("Updated network with ID - %s" % network.id)
|
||||
|
||||
# delete_Network - Deletes the given network
|
||||
def delete_Network(self, network):
|
||||
self.debug('Deleting Network - %s' % network.name)
|
||||
# Wait for network garbage collection before network deletion
|
||||
wait_for_cleanup(self.api_client,
|
||||
["network.gc.interval", "network.gc.wait"]
|
||||
)
|
||||
self.debug("Deleting Network with ID - %s" % network.id)
|
||||
network.delete(self.api_client)
|
||||
if network in self.cleanup:
|
||||
self.cleanup.remove(network)
|
||||
self.debug('Deleted Network - %s' % network.name)
|
||||
self.debug("Deleted Network with ID - %s" % network.id)
|
||||
|
||||
# create_VM_in_Network - Creates a VM in the given network, the vm_key - is the key for the services on the vm.
|
||||
def create_VM_in_Network(self, network, vm_key="virtual_machine", host_id=None, start_vm=True):
|
||||
self.debug('Creating VM in network=%s' % network.name)
|
||||
self.debug('Passed vm_key=%s' % vm_key)
|
||||
# create_VM - Creates VM in the given network, vm_key - Key for the services on the VM
|
||||
def create_VM(self, network, vm_key="virtual_machine", host_id=None, start_vm=True):
|
||||
self.debug("Creating VM in network with ID - %s" % network.id)
|
||||
self.debug("Passed vm_key - %s" % vm_key)
|
||||
self.test_data[vm_key]["zoneid"] = self.zone.id
|
||||
self.test_data[vm_key]["template"] = self.template.id
|
||||
vm = VirtualMachine.create(
|
||||
self.api_client,
|
||||
self.test_data[vm_key],
|
||||
accountid=self.account.name,
|
||||
domainid=self.account.domainid,
|
||||
serviceofferingid=self.service_offering.id,
|
||||
networkids=[str(network.id)],
|
||||
startvm=start_vm,
|
||||
hostid=host_id
|
||||
)
|
||||
self.debug('Created VM=%s in network=%s' % (vm.id, network.name))
|
||||
vm = VirtualMachine.create(self.api_client,
|
||||
self.test_data[vm_key],
|
||||
accountid=self.account.name,
|
||||
domainid=self.account.domainid,
|
||||
serviceofferingid=self.service_offering.id,
|
||||
networkids=[str(network.id)],
|
||||
startvm=start_vm,
|
||||
hostid=host_id
|
||||
)
|
||||
self.debug("Created VM with ID - %s in network with ID - %s" % (vm.id, network.id))
|
||||
self.cleanup.append(vm)
|
||||
return vm
|
||||
|
||||
# delete_VM - Deletes the given VM
|
||||
def delete_VM(self, vm):
|
||||
self.debug('Deleting VM - %s' % vm.name)
|
||||
vm.delete(self.api_client)
|
||||
# Wait for expunge interval to cleanup VM
|
||||
wait_for_cleanup(self.api_client,
|
||||
["expunge.delay", "expunge.interval"]
|
||||
)
|
||||
def delete_VM(self, vm, expunge=True):
|
||||
self.debug("Deleting VM with ID - %s" % vm.id)
|
||||
vm.delete(self.api_client, expunge=expunge)
|
||||
if vm in self.cleanup:
|
||||
self.cleanup.remove(vm)
|
||||
self.debug('Deleted VM - %s' % vm.name)
|
||||
self.debug("Deleted VM with ID - %s" % vm.id)
|
||||
|
||||
# acquire_Public_IP - Acquires a public IP for the given network
|
||||
def acquire_Public_IP(self, network, vpc=None):
|
||||
self.debug("Associating public IP for network: %s" % network.name)
|
||||
public_ip = PublicIPAddress.create(self.api_client,
|
||||
accountid=self.account.name,
|
||||
zoneid=self.zone.id,
|
||||
domainid=self.account.domainid,
|
||||
networkid=network.id if vpc is None else None,
|
||||
vpcid=vpc.id if vpc else self.vpc.id if hasattr(self, "vpc") else None
|
||||
)
|
||||
self.debug("Associated %s with network %s" % (public_ip.ipaddress.ipaddress,
|
||||
network.id))
|
||||
return public_ip
|
||||
|
||||
# create_StaticNatRule_For_VM - Creates static NAT rule for the given network , VM on the given public ip
|
||||
def create_StaticNatRule_For_VM(self, vm, public_ip, network, vmguestip=None):
|
||||
self.debug("Enabling static NAT for IP: %s" %
|
||||
public_ip.ipaddress.ipaddress)
|
||||
StaticNATRule.enable(
|
||||
self.api_client,
|
||||
ipaddressid=public_ip.ipaddress.id,
|
||||
virtualmachineid=vm.id,
|
||||
networkid=network.id,
|
||||
vmguestip=vmguestip
|
||||
)
|
||||
self.debug("Static NAT enabled for IP: %s" %
|
||||
public_ip.ipaddress.ipaddress)
|
||||
|
||||
# delete_StaticNatRule_For_VM - Deletes the static NAT rule for the given VM
|
||||
def delete_StaticNatRule_For_VM(self, vm, public_ip):
|
||||
self.debug("Disabling static NAT for IP: %s" %
|
||||
public_ip.ipaddress.ipaddress)
|
||||
StaticNATRule.disable(
|
||||
self.api_client,
|
||||
ipaddressid=public_ip.ipaddress.id,
|
||||
virtualmachineid=vm.id
|
||||
)
|
||||
self.debug("Static NAT disabled for IP: %s" %
|
||||
public_ip.ipaddress.ipaddress)
|
||||
|
||||
# create_firewall_rule - Creates the Ingress firewall rule on the given public ip
|
||||
def create_firewall_rule(self, public_ip, rule=None):
|
||||
if not rule:
|
||||
rule = self.test_data["ingress_rule"]
|
||||
self.debug("Adding an Ingress Firewall rule to make Guest VMs accessible through Static NAT")
|
||||
return FireWallRule.create(self.api_client,
|
||||
ipaddressid=public_ip.ipaddress.id,
|
||||
protocol=rule["protocol"],
|
||||
cidrlist=rule["cidrlist"],
|
||||
startport=rule["startport"],
|
||||
endport=rule["endport"]
|
||||
)
|
||||
|
||||
# create_egress_firewall_rule - Creates the Egress firewall rule on the given public ip
|
||||
def create_egress_firewall_rule(self, network, rule):
|
||||
self.debug("Adding an Egress Firewall rule to allow/deny outgoing traffic from Guest VMs")
|
||||
return EgressFireWallRule.create(self.api_client,
|
||||
networkid=network.id,
|
||||
protocol=rule["protocol"],
|
||||
cidrlist=rule["cidrlist"],
|
||||
startport=rule["startport"],
|
||||
endport=rule["endport"]
|
||||
)
|
||||
|
||||
# create_network_acl_list - Creates network ACL list in the given VPC
|
||||
def create_network_acl_list(self, name, description, vpc):
|
||||
self.debug("Adding NetworkACL list in VPC: %s" % vpc.id)
|
||||
return NetworkACLList.create(self.api_client,
|
||||
services={},
|
||||
name=name,
|
||||
description=description,
|
||||
vpcid=vpc.id
|
||||
)
|
||||
|
||||
# create_network_acl_rule - Creates network ACL rule Ingree/Egress in the given network
|
||||
def create_network_acl_rule(self, rule, traffic_type="Ingress", network=None, acl_list=None):
|
||||
self.debug("Adding NetworkACL rule: %s" % rule)
|
||||
return NetworkACL.create(self.api_client,
|
||||
networkid=network.id if network else None,
|
||||
services=rule,
|
||||
traffictype=traffic_type,
|
||||
aclid=acl_list.id if acl_list else None
|
||||
)
|
||||
|
||||
# migrate_vm - Migrates the VM to a different host if available
|
||||
def migrate_vm(self, vm):
|
||||
self.debug("Checking if a host is available for migration?")
|
||||
hosts = Host.listForMigration(self.api_client)
|
||||
self.assertEqual(isinstance(hosts, list), True,
|
||||
"List hosts should return a valid list"
|
||||
)
|
||||
# Remove the host of current VM from the hosts list
|
||||
hosts[:] = [host for host in hosts if host.id != vm.hostid]
|
||||
if len(hosts) <= 0:
|
||||
self.skipTest("No host available for migration. Test requires at-least 2 hosts")
|
||||
host = hosts[0]
|
||||
self.debug("Migrating VM-ID: %s to Host: %s" % (vm.id, host.id))
|
||||
try:
|
||||
vm.migrate(self.api_client, hostid=host.id)
|
||||
except Exception as e:
|
||||
self.fail("Failed to migrate instance, %s" % e)
|
||||
|
||||
# get_network_router - returns the router for the given network
|
||||
def get_network_router(self, network):
|
||||
self.debug("Finding the virtual router for network: %s" % network.name)
|
||||
# get_Router - Returns router for the given network
|
||||
def get_Router(self, network):
|
||||
self.debug("Finding the virtual router for network with ID - %s" % network.id)
|
||||
routers = Router.list(self.api_client,
|
||||
networkid=network.id,
|
||||
listall=True
|
||||
@ -441,50 +296,120 @@ class nuageTestCase(cloudstackTestCase):
|
||||
)
|
||||
return routers[0]
|
||||
|
||||
# stop_network_router - Stops the given network router
|
||||
def stop_network_router(self, router):
|
||||
self.debug("Stopping Router with ID: %s" % router.id)
|
||||
cmd = stopRouter.stopRouterCmd()
|
||||
cmd.id = router.id
|
||||
self.api_client.stopRouter(cmd)
|
||||
# acquire_PublicIPAddress - Acquires public IP address for the given network/VPC
|
||||
def acquire_PublicIPAddress(self, network, vpc=None):
|
||||
self.debug("Associating public IP for network with ID - %s" % network.id)
|
||||
public_ip = PublicIPAddress.create(self.api_client,
|
||||
accountid=self.account.name,
|
||||
zoneid=self.zone.id,
|
||||
domainid=self.account.domainid,
|
||||
networkid=network.id if vpc is None else None,
|
||||
vpcid=vpc.id if vpc else self.vpc.id if hasattr(self, "vpc") else None
|
||||
)
|
||||
self.debug("Associated public IP address - %s with network with ID - %s" %
|
||||
(public_ip.ipaddress.ipaddress, network.id))
|
||||
return public_ip
|
||||
|
||||
# start_network_router - Starts the given network router
|
||||
def start_network_router(self, router):
|
||||
self.debug("Starting Router with ID: %s" % router.id)
|
||||
cmd = startRouter.startRouterCmd()
|
||||
cmd.id = router.id
|
||||
self.api_client.startRouter(cmd)
|
||||
# create_StaticNatRule_For_VM - Creates static NAT rule on the given public IP for the given network and VM
|
||||
def create_StaticNatRule_For_VM(self, vm, public_ip, network, vmguestip=None):
|
||||
self.debug("Enabling static NAT for public IP - %s" % public_ip.ipaddress.ipaddress)
|
||||
StaticNATRule.enable(self.api_client,
|
||||
ipaddressid=public_ip.ipaddress.id,
|
||||
virtualmachineid=vm.id,
|
||||
networkid=network.id,
|
||||
vmguestip=vmguestip
|
||||
)
|
||||
self.debug("Static NAT enabled for public IP - %s" % public_ip.ipaddress.ipaddress)
|
||||
|
||||
# ssh_into_vm - Gets into the shell of the given VM
|
||||
def ssh_into_vm(self, vm, public_ip):
|
||||
self.debug("SSH into VM=%s on public_ip=%s" % (vm.name, public_ip.ipaddress.ipaddress))
|
||||
# delete_StaticNatRule_For_VM - Deletes static NAT rule on the given public IP for the given VM
|
||||
def delete_StaticNatRule_For_VM(self, vm, public_ip):
|
||||
self.debug("Disabling static NAT for public IP - %s" % public_ip.ipaddress.ipaddress)
|
||||
StaticNATRule.disable(self.api_client,
|
||||
ipaddressid=public_ip.ipaddress.id,
|
||||
virtualmachineid=vm.id
|
||||
)
|
||||
self.debug("Static NAT disabled for public IP - %s" % public_ip.ipaddress.ipaddress)
|
||||
|
||||
# create_FirewallRule - Creates Ingress firewall rule on the given public IP
|
||||
def create_FirewallRule(self, public_ip, rule=None):
|
||||
if not rule:
|
||||
rule = self.test_data["ingress_rule"]
|
||||
self.debug("Adding an Ingress Firewall rule to make Guest VMs accessible through Static NAT - %s" % rule)
|
||||
return FireWallRule.create(self.api_client,
|
||||
ipaddressid=public_ip.ipaddress.id,
|
||||
protocol=rule["protocol"],
|
||||
cidrlist=rule["cidrlist"],
|
||||
startport=rule["startport"],
|
||||
endport=rule["endport"]
|
||||
)
|
||||
|
||||
# create_EgressFirewallRule - Creates Egress firewall rule on the given public IP
|
||||
def create_EgressFirewallRule(self, network, rule):
|
||||
self.debug("Adding an Egress Firewall rule to allow/deny outgoing traffic from Guest VMs - %s" % rule)
|
||||
return EgressFireWallRule.create(self.api_client,
|
||||
networkid=network.id,
|
||||
protocol=rule["protocol"],
|
||||
cidrlist=rule["cidrlist"],
|
||||
startport=rule["startport"],
|
||||
endport=rule["endport"]
|
||||
)
|
||||
|
||||
# create_NetworkAclList - Creates network ACL list in the given VPC
|
||||
def create_NetworkAclList(self, name, description, vpc):
|
||||
self.debug("Adding NetworkACL list in VPC with ID - %s" % vpc.id)
|
||||
return NetworkACLList.create(self.api_client,
|
||||
services={},
|
||||
name=name,
|
||||
description=description,
|
||||
vpcid=vpc.id
|
||||
)
|
||||
|
||||
# create_NetworkAclRule - Creates Ingress/Egress network ACL rule in the given network/acl list
|
||||
def create_NetworkAclRule(self, rule, traffic_type="Ingress", network=None, acl_list=None):
|
||||
self.debug("Adding NetworkACL rule - %s" % rule)
|
||||
if acl_list:
|
||||
return NetworkACL.create(self.api_client,
|
||||
networkid=network.id if network else None,
|
||||
services=rule,
|
||||
traffictype=traffic_type,
|
||||
aclid=acl_list.id
|
||||
)
|
||||
else:
|
||||
return NetworkACL.create(self.api_client,
|
||||
networkid=network.id if network else None,
|
||||
services=rule,
|
||||
traffictype=traffic_type
|
||||
)
|
||||
|
||||
# ssh_into_VM - Gets into the shell of the given VM
|
||||
def ssh_into_VM(self, vm, public_ip):
|
||||
self.debug("SSH into VM with ID - %s on public IP address - %s" % (vm.id, public_ip.ipaddress.ipaddress))
|
||||
ssh_client = vm.get_ssh_client(ipaddress=public_ip.ipaddress.ipaddress)
|
||||
return ssh_client
|
||||
|
||||
# execute_cmd - Executes the given command on the given ssh client
|
||||
def execute_cmd(self, ssh_client, cmd):
|
||||
self.debug("EXECUTE SSH COMMAND: " + cmd)
|
||||
self.debug("SSH client executing command - %s" % cmd)
|
||||
ret_data = ""
|
||||
out_list = ssh_client.execute(cmd)
|
||||
if out_list is not None:
|
||||
ret_data = ' '.join(map(str, out_list)).strip()
|
||||
self.debug("ssh execute cmd result=" + ret_data)
|
||||
self.debug("SSH client executed command result - %s" % ret_data)
|
||||
else:
|
||||
self.debug("ssh execute cmd result is None")
|
||||
self.debug("SSH client executed command result is None")
|
||||
return ret_data
|
||||
|
||||
# wget_from_server - fetches the index.html file from the given public Ip
|
||||
# wget_from_server - Fetches index.html file of web server running with the given public IP
|
||||
def wget_from_server(self, public_ip):
|
||||
import urllib
|
||||
self.debug("wget from a http server on public_ip=%s" % public_ip.ipaddress.ipaddress)
|
||||
wget_file = urllib.urlretrieve("http://%s/index.html" % public_ip.ipaddress.ipaddress,
|
||||
filename="index.html"
|
||||
)
|
||||
return wget_file
|
||||
self.debug("wget from a http server on public IP address - %s" % public_ip.ipaddress.ipaddress)
|
||||
filename, headers = urllib.urlretrieve("http://%s/index.html" % public_ip.ipaddress.ipaddress,
|
||||
filename="index.html"
|
||||
)
|
||||
return filename, headers
|
||||
|
||||
# validate_NetworkServiceProvider - Validates the Network Service Provider
|
||||
# in the Nuage VSP Physical Network - matches the given provider name
|
||||
# against the list of providers fetched
|
||||
# validate_NetworkServiceProvider - Validates the given Network Service Provider in the Nuage VSP Physical Network,
|
||||
# matches the given provider name and state against the list of providers fetched
|
||||
def validate_NetworkServiceProvider(self, provider_name, state=None):
|
||||
"""Validates the Network Service Provider in the Nuage VSP Physical Network"""
|
||||
self.debug("Check if the Network Service Provider is created successfully ?")
|
||||
@ -499,12 +424,13 @@ class nuageTestCase(cloudstackTestCase):
|
||||
)
|
||||
if state:
|
||||
self.assertEqual(providers[0].state, state,
|
||||
"Network Service Provider state should be '%s'" % state
|
||||
"Network Service Provider state should be in state - %s" % state
|
||||
)
|
||||
self.debug("Network Service Provider creation successfully validated - %s" % provider_name)
|
||||
self.debug("Network Service Provider creation successfully validated for %s" % provider_name)
|
||||
|
||||
# validate_vpc_offering - Validates the VPC offering, matches the given VPC off name against the list of VPC offerings fetched
|
||||
def validate_vpc_offering(self, vpc_offering, state=None):
|
||||
# validate_VpcOffering - Validates the given VPC offering,
|
||||
# matches the given VPC offering name and state against the list of VPC offerings fetched
|
||||
def validate_VpcOffering(self, vpc_offering, state=None):
|
||||
"""Validates the VPC offering"""
|
||||
self.debug("Check if the VPC offering is created successfully ?")
|
||||
vpc_offs = VpcOffering.list(self.api_client,
|
||||
@ -518,12 +444,13 @@ class nuageTestCase(cloudstackTestCase):
|
||||
)
|
||||
if state:
|
||||
self.assertEqual(vpc_offs[0].state, state,
|
||||
"VPC offering state should be '%s'" % state
|
||||
"VPC offering state should be in state - %s" % state
|
||||
)
|
||||
self.debug("VPC offering creation successfully validated - %s" % vpc_offering.name)
|
||||
self.debug("VPC offering creation successfully validated for %s" % vpc_offering.name)
|
||||
|
||||
# validate_vpc - Validates the given VPC matches, the given VPC name against the list of VPCs fetched
|
||||
def validate_vpc(self, vpc, state=None):
|
||||
# validate_Vpc - Validates the given VPC,
|
||||
# matches the given VPC name and state against the list of VPCs fetched
|
||||
def validate_Vpc(self, vpc, state=None):
|
||||
"""Validates the VPC"""
|
||||
self.debug("Check if the VPC is created successfully ?")
|
||||
vpcs = VPC.list(self.api_client,
|
||||
@ -537,14 +464,13 @@ class nuageTestCase(cloudstackTestCase):
|
||||
)
|
||||
if state:
|
||||
self.assertEqual(vpcs[0].state, state,
|
||||
"VPC state should be '%s'" % state
|
||||
"VPC state should be in state - %s" % state
|
||||
)
|
||||
self.debug("VPC creation successfully validated - %s" % vpc.name)
|
||||
self.debug("VPC creation successfully validated for %s" % vpc.name)
|
||||
|
||||
# validate_network_offering - Validates the given Network offering
|
||||
# matches the given network offering name against the list of network
|
||||
# offerings fetched
|
||||
def validate_network_offering(self, net_offering, state=None):
|
||||
# validate_NetworkOffering - Validates the given Network offering,
|
||||
# matches the given network offering name and state against the list of network offerings fetched
|
||||
def validate_NetworkOffering(self, net_offering, state=None):
|
||||
"""Validates the Network offering"""
|
||||
self.debug("Check if the Network offering is created successfully ?")
|
||||
net_offs = NetworkOffering.list(self.api_client,
|
||||
@ -558,13 +484,14 @@ class nuageTestCase(cloudstackTestCase):
|
||||
)
|
||||
if state:
|
||||
self.assertEqual(net_offs[0].state, state,
|
||||
"Network offering state should be '%s'" % state
|
||||
"Network offering state should be in state - %s" % state
|
||||
)
|
||||
self.debug("Network offering creation successfully validated - %s" % net_offering.name)
|
||||
self.debug("Network offering creation successfully validated for %s" % net_offering.name)
|
||||
|
||||
# validate_network - Validates the network - matches the given network name against the list of networks fetched
|
||||
def validate_network(self, network, state=None):
|
||||
"""Validates the network"""
|
||||
# validate_Network - Validates the given network,
|
||||
# matches the given network name and state against the list of networks fetched
|
||||
def validate_Network(self, network, state=None):
|
||||
"""Validates the Network"""
|
||||
self.debug("Check if the network is created successfully ?")
|
||||
networks = Network.list(self.api_client,
|
||||
id=network.id
|
||||
@ -577,28 +504,13 @@ class nuageTestCase(cloudstackTestCase):
|
||||
)
|
||||
if state:
|
||||
self.assertEqual(networks[0].state, state,
|
||||
"Network state should be '%s'" % state
|
||||
"Network state should be in state - %s" % state
|
||||
)
|
||||
self.debug("Network creation successfully validated - %s" % network.name)
|
||||
self.debug("Network creation successfully validated for %s" % network.name)
|
||||
|
||||
# check_router_state - Fetches the list of routers and their states and matches the given router's state
|
||||
def check_router_state(self, router, state=None):
|
||||
self.debug("Check if the virtual router is in state - %s" % state)
|
||||
routers = Router.list(self.api_client,
|
||||
id=router.id,
|
||||
listall=True
|
||||
)
|
||||
self.assertEqual(isinstance(routers, list), True,
|
||||
"List router should return a valid list"
|
||||
)
|
||||
if state:
|
||||
self.assertEqual(routers[0].state, state,
|
||||
"Virtual router is not in the expected state"
|
||||
)
|
||||
self.debug("Virtual router is in the expected state - %s" % state)
|
||||
|
||||
# check_vm_state - Fetches the list of VMs and their states and matches the given VM's state
|
||||
def check_vm_state(self, vm, state=None):
|
||||
# check_VM_state - Checks if the given VM is in the expected state form the list of fetched VMs
|
||||
def check_VM_state(self, vm, state=None):
|
||||
"""Validates the VM state"""
|
||||
self.debug("Check if the VM instance is in state - %s" % state)
|
||||
vms = VirtualMachine.list(self.api_client,
|
||||
id=vm.id,
|
||||
@ -611,12 +523,30 @@ class nuageTestCase(cloudstackTestCase):
|
||||
self.assertEqual(vms[0].state, state,
|
||||
"Virtual machine is not in the expected state"
|
||||
)
|
||||
self.debug("Virtual machine is in the expected state - %s" % state)
|
||||
self.debug("Virtual machine instance - %s is in the expected state - %s" % (vm.name, state))
|
||||
|
||||
# validate_Public_IP - Looks if the given public ip is in the allocated state form the list of fetched public IPs
|
||||
def validate_Public_IP(self, public_ip, network, static_nat=False, vm=None):
|
||||
"""Validates the Public IP"""
|
||||
self.debug("Check if the Public IP is successfully assigned to the network ?")
|
||||
# check_Router_state - Checks if the given router is in the expected state form the list of fetched routers
|
||||
def check_Router_state(self, router, state=None):
|
||||
"""Validates the Router state"""
|
||||
self.debug("Check if the virtual router instance is in state - %s" % state)
|
||||
routers = Router.list(self.api_client,
|
||||
id=router.id,
|
||||
listall=True
|
||||
)
|
||||
self.assertEqual(isinstance(routers, list), True,
|
||||
"List router should return a valid list"
|
||||
)
|
||||
if state:
|
||||
self.assertEqual(routers[0].state, state,
|
||||
"Virtual router is not in the expected state"
|
||||
)
|
||||
self.debug("Virtual router instance - %s is in the expected state - %s" % (router.name, state))
|
||||
|
||||
# validate_PublicIPAddress - Validates if the given public IP address is in the expected state form the list of
|
||||
# fetched public IP addresses
|
||||
def validate_PublicIPAddress(self, public_ip, network, static_nat=False, vm=None):
|
||||
"""Validates the Public IP Address"""
|
||||
self.debug("Check if the public IP is successfully assigned to the network ?")
|
||||
public_ips = PublicIPAddress.list(self.api_client,
|
||||
id=public_ip.ipaddress.id,
|
||||
networkid=network.id,
|
||||
@ -624,24 +554,30 @@ class nuageTestCase(cloudstackTestCase):
|
||||
listall=True
|
||||
)
|
||||
self.assertEqual(isinstance(public_ips, list), True,
|
||||
"List public Ip for network should return a valid list"
|
||||
"List public IP for network should return a valid list"
|
||||
)
|
||||
self.assertEqual(public_ips[0].ipaddress, public_ip.ipaddress.ipaddress,
|
||||
"List public Ip for network should list the assigned public Ip address"
|
||||
"List public IP for network should list the assigned public IP address"
|
||||
)
|
||||
self.assertEqual(public_ips[0].state, "Allocated",
|
||||
"Assigned public Ip is not in the allocated state"
|
||||
"Assigned public IP is not in the allocated state"
|
||||
)
|
||||
if static_nat and vm:
|
||||
self.assertEqual(public_ips[0].virtualmachineid, vm.id,
|
||||
"Static NAT Rule not enabled for the VM using the assigned public Ip"
|
||||
"Static NAT Rule not enabled for the VM using the assigned public IP"
|
||||
)
|
||||
self.debug("Assigned Public IP is successfully validated - %s" % public_ip.ipaddress.ipaddress)
|
||||
self.debug("Assigned Public IP address - %s is successfully validated" % public_ip.ipaddress.ipaddress)
|
||||
|
||||
# VSD verifications
|
||||
# VSD is a programmable policy and analytics engine of Nuage VSP SDN platform
|
||||
|
||||
def fetch_by_external_id(self, fetcher, *cs_objects):
|
||||
""" Fetches a child object by external id using the given fetcher, and uuids of the given cloudstack objects.
|
||||
# get_externalID - Returns corresponding external ID of the given object in VSD
|
||||
def get_externalID(self, object_id):
|
||||
return object_id + "@" + self.cms_id
|
||||
|
||||
# fetch_by_externalID - Returns VSD object with the given external ID
|
||||
def fetch_by_externalID(self, fetcher, *cs_objects):
|
||||
""" Fetches a child object by external ID using the given fetcher, and uuids of the given cloudstack objects.
|
||||
E.G.
|
||||
- fetch_by_external_id(vsdk.NUSubnet(id="954de425-b860-410b-be09-c560e7dbb474").vms, cs_vm)
|
||||
- fetch_by_external_id(session.user.floating_ips, cs_network, cs_public_ip)
|
||||
@ -651,12 +587,8 @@ class nuageTestCase(cloudstackTestCase):
|
||||
"""
|
||||
return fetcher.get_first(filter="externalID BEGINSWITH '%s'" % ":".join([o.id for o in cs_objects]))
|
||||
|
||||
# VSD verifications using cms_vspk_wrapper
|
||||
|
||||
def get_externalID(self, object_id):
|
||||
return object_id + "@" + self.cms_id
|
||||
|
||||
# verify_vsp_network - Fetches the vsd domain, vsd zone and vsd subnet and Verifies the given network/VPC values match the fetched values
|
||||
# verify_vsp_network - Verifies the given domain and network/VPC
|
||||
# against the corresponding installed enterprise, domain, zone, and subnet in VSD
|
||||
def verify_vsp_network(self, domain_id, network, vpc=None):
|
||||
vsd_enterprise = self.vsd.get_enterprise(name=domain_id)
|
||||
if vpc:
|
||||
@ -677,24 +609,24 @@ class nuageTestCase(cloudstackTestCase):
|
||||
self.debug(vsd_zone)
|
||||
self.debug(vsd_subnet)
|
||||
if vpc:
|
||||
self.assertEqual(vsd_domain['description'], "VPC_" + vpc.name,
|
||||
self.assertEqual(vsd_domain["description"], "VPC_" + vpc.name,
|
||||
"VSD domain description should match VPC name in CloudStack"
|
||||
)
|
||||
self.assertEqual(vsd_zone['description'], "VPC_" + vpc.name,
|
||||
self.assertEqual(vsd_zone["description"], "VPC_" + vpc.name,
|
||||
"VSD zone description should match VPC name in CloudStack"
|
||||
)
|
||||
else:
|
||||
self.assertEqual(vsd_domain['description'], network.name,
|
||||
"VSD domain description should match Isolated Network name in CloudStack"
|
||||
self.assertEqual(vsd_domain["description"], network.name,
|
||||
"VSD domain description should match network name in CloudStack"
|
||||
)
|
||||
self.assertEqual(vsd_zone['description'], network.name,
|
||||
"VSD zone description should match Isolated Network name in CloudStack"
|
||||
self.assertEqual(vsd_zone["description"], network.name,
|
||||
"VSD zone description should match network name in CloudStack"
|
||||
)
|
||||
self.assertEqual(vsd_subnet['description'], network.name,
|
||||
"VSD subnet description should match Isolated Network name in CloudStack"
|
||||
self.assertEqual(vsd_subnet["description"], network.name,
|
||||
"VSD subnet description should match network name in CloudStack"
|
||||
)
|
||||
|
||||
# verify_vsp_vm - Fetches the vsd vport, vsd vm and interface and Verifies the given VM values match the fetched values
|
||||
# verify_vsp_vm - Verifies the given VM deployment and state in VSD
|
||||
def verify_vsp_vm(self, vm, stopped=None):
|
||||
ext_vm_id = self.get_externalID(vm.id)
|
||||
for nic in vm.nic:
|
||||
@ -705,10 +637,10 @@ class nuageTestCase(cloudstackTestCase):
|
||||
self.debug("SHOW VPORT and VM INTERFACE DATA FORMAT IN VSD")
|
||||
self.debug(vsd_vport)
|
||||
self.debug(vsd_vm_interface)
|
||||
self.assertEqual(vsd_vport['active'], True,
|
||||
self.assertEqual(vsd_vport["active"], True,
|
||||
"VSD VM vport should be active"
|
||||
)
|
||||
self.assertEqual(vsd_vm_interface['IPAddress'], nic.ipaddress,
|
||||
self.assertEqual(vsd_vm_interface["IPAddress"], nic.ipaddress,
|
||||
"VSD VM interface IP address should match VM's NIC IP address in CloudStack"
|
||||
)
|
||||
vsd_vm = self.vsd.get_vm(externalID=ext_vm_id)
|
||||
@ -716,15 +648,15 @@ class nuageTestCase(cloudstackTestCase):
|
||||
self.debug(vsd_vm)
|
||||
if not self.isSimulator:
|
||||
if stopped:
|
||||
self.assertEqual(vsd_vm['status'], "DELETE_PENDING",
|
||||
self.assertEqual(vsd_vm["status"], "DELETE_PENDING",
|
||||
"VM state in VSD should be DELETE_PENDING"
|
||||
)
|
||||
else:
|
||||
self.assertEqual(vsd_vm['status'], vm.state.upper(),
|
||||
self.assertEqual(vsd_vm["status"], vm.state.upper(),
|
||||
"VM state in VSD should match its state in CloudStack"
|
||||
)
|
||||
# verify_vsp_router - Fetches the vsd router and Verifies the given router status match the fetched status
|
||||
|
||||
# verify_vsp_router - Verifies the given network router deployment and state in VSD
|
||||
def verify_vsp_router(self, router, stopped=None):
|
||||
ext_router_id = self.get_externalID(router.id)
|
||||
vsd_router = self.vsd.get_vm(externalID=ext_router_id)
|
||||
@ -732,22 +664,42 @@ class nuageTestCase(cloudstackTestCase):
|
||||
self.debug(vsd_router)
|
||||
if not self.isSimulator:
|
||||
if stopped:
|
||||
self.assertEqual(vsd_router['status'], "DELETE_PENDING",
|
||||
self.assertEqual(vsd_router["status"], "DELETE_PENDING",
|
||||
"Router state in VSD should be DELETE_PENDING"
|
||||
)
|
||||
else:
|
||||
self.assertEqual(vsd_router['status'], router.state.upper(),
|
||||
self.assertEqual(vsd_router["status"], router.state.upper(),
|
||||
"Router state in VSD should match its state in CloudStack"
|
||||
)
|
||||
|
||||
# verify_vsp_floating_ip - Verifies the floating IPs on the given public IP against the VSD FIP
|
||||
# verify_vsp_LB_device - Verifies the given LB device deployment and state in VSD
|
||||
def verify_vsp_LB_device(self, lb_device, stopped=None):
|
||||
ext_lb_device_id = self.get_externalID(lb_device.id)
|
||||
vsd_lb_device = self.vsd.get_vm(externalID=ext_lb_device_id)
|
||||
self.debug("SHOW LB Device DATA FORMAT IN VSD")
|
||||
self.debug(vsd_lb_device)
|
||||
if not self.isSimulator:
|
||||
if stopped:
|
||||
self.assertEqual(vsd_lb_device['status'], "DELETE_PENDING",
|
||||
"LB device state in VSD should be DELETE_PENDING"
|
||||
)
|
||||
else:
|
||||
self.assertEqual(vsd_lb_device['status'], lb_device.state.upper(),
|
||||
"LB device state in VSD should match its state in CloudStack"
|
||||
)
|
||||
|
||||
# verify_vsp_floating_ip - Verifies the static nat rule on the given public IP of the given network and VM
|
||||
# against the corresponding installed FIP in VSD
|
||||
def verify_vsp_floating_ip(self, network, vm, public_ipaddress, vpc=None):
|
||||
ext_fip_id = self.get_externalID(network.id + ":" + public_ipaddress.id)
|
||||
if vpc:
|
||||
ext_fip_id = self.get_externalID(vpc.id + ":" + public_ipaddress.id)
|
||||
else:
|
||||
ext_fip_id = self.get_externalID(network.id + ":" + public_ipaddress.id)
|
||||
vsd_fip = self.vsd.get_floating_ip(externalID=ext_fip_id)
|
||||
self.debug("SHOW FLOATING IP DATA FORMAT IN VSD")
|
||||
self.debug(vsd_fip)
|
||||
self.assertEqual(vsd_fip['address'], public_ipaddress.ipaddress,
|
||||
"Floating IP address in VSD should match acquired Public IP address in CloudStack"
|
||||
self.assertEqual(vsd_fip["address"], public_ipaddress.ipaddress,
|
||||
"Floating IP address in VSD should match acquired public IP address in CloudStack"
|
||||
)
|
||||
if vpc:
|
||||
ext_network_id = self.get_externalID(vpc.id)
|
||||
@ -756,28 +708,27 @@ class nuageTestCase(cloudstackTestCase):
|
||||
vsd_domain = self.vsd.get_domain(externalID=ext_network_id)
|
||||
self.debug("SHOW NETWORK DATA FORMAT IN VSD")
|
||||
self.debug(vsd_domain)
|
||||
self.assertEqual(vsd_domain['ID'], vsd_fip['parentID'],
|
||||
self.assertEqual(vsd_domain["ID"], vsd_fip["parentID"],
|
||||
"Floating IP in VSD should be associated with the correct VSD domain, "
|
||||
"which in turn should correspond to the correct VPC (or) Isolated network in CloudStack"
|
||||
"which in turn should correspond to the correct VPC (or) network in CloudStack"
|
||||
)
|
||||
ext_subnet_id = self.get_externalID(network.id)
|
||||
vsd_subnet = self.vsd.get_subnet(externalID=ext_subnet_id)
|
||||
for nic in vm.nic:
|
||||
if nic.networkname == vsd_subnet['description']:
|
||||
if nic.networkname == vsd_subnet["description"]:
|
||||
ext_network_id = self.get_externalID(nic.networkid)
|
||||
ext_nic_id = self.get_externalID(nic.id)
|
||||
vsd_vport = self.vsd.get_vport(subnet_externalID=ext_network_id, vport_externalID=ext_nic_id)
|
||||
self.debug("SHOW VM VPORT DATA FORMAT IN VSD")
|
||||
self.debug(vsd_vport)
|
||||
self.assertEqual(vsd_vport['associatedFloatingIPID'], vsd_fip['ID'],
|
||||
self.assertEqual(vsd_vport["associatedFloatingIPID"], vsd_fip["ID"],
|
||||
"Floating IP in VSD should be associated to the correct VSD vport, "
|
||||
"which in turn should correspond to the correct Static NAT enabled VM "
|
||||
"and Isolated Network in CloudStack"
|
||||
"and network in CloudStack"
|
||||
)
|
||||
|
||||
# verify_vsp_firewall_rule - Verifies the start port, destination port,
|
||||
# protocol of the given firewall rule Ingress/Egress against the VSD
|
||||
# firewall rule
|
||||
# verify_vsp_firewall_rule - Verifies the given Ingress/Egress firewall rule
|
||||
# against the corresponding installed firewall rule in VSD
|
||||
def verify_vsp_firewall_rule(self, firewall_rule, traffic_type="Ingress"):
|
||||
ext_fw_id = self.get_externalID(firewall_rule.id)
|
||||
if traffic_type is "Ingress":
|
||||
@ -787,11 +738,11 @@ class nuageTestCase(cloudstackTestCase):
|
||||
self.debug("SHOW ACL ENTRY IN VSD")
|
||||
self.debug(vsd_fw_rule)
|
||||
dest_port = str(firewall_rule.startport) + "-" + str(firewall_rule.endport)
|
||||
self.assertEqual(vsd_fw_rule['destinationPort'], dest_port,
|
||||
"Destination Port in VSD should match Destination Port in CloudStack"
|
||||
self.assertEqual(vsd_fw_rule["destinationPort"], dest_port,
|
||||
"Destination port in VSD should match destination port in CloudStack"
|
||||
)
|
||||
vsd_protocol = str(vsd_fw_rule['protocol'])
|
||||
self.debug("vsd protocol " + vsd_protocol)
|
||||
vsd_protocol = str(vsd_fw_rule["protocol"])
|
||||
self.debug("vsd protocol - %s" % vsd_protocol)
|
||||
protocol = "tcp"
|
||||
if vsd_protocol == 6:
|
||||
protocol = "tcp"
|
||||
@ -800,5 +751,5 @@ class nuageTestCase(cloudstackTestCase):
|
||||
elif vsd_protocol == 17:
|
||||
protocol = "udp"
|
||||
self.assertEqual(protocol, firewall_rule.protocol.lower(),
|
||||
"Protocol in VSD should match Protocol in CloudStack"
|
||||
"Protocol in VSD should match protocol in CloudStack"
|
||||
)
|
||||
|
||||
@ -15,26 +15,29 @@
|
||||
# specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
""" Component tests for - userdata
|
||||
""" Component tests for user data and password reset functionality with Nuage VSP SDN plugin
|
||||
"""
|
||||
# Import Local Modules
|
||||
from marvin.lib.base import (Account,
|
||||
VirtualMachine,
|
||||
Volume,
|
||||
Template)
|
||||
from nose.plugins.attrib import attr
|
||||
from nuageTestCase import nuageTestCase
|
||||
from marvin.lib.base import (Account,
|
||||
Template,
|
||||
VirtualMachine,
|
||||
Volume)
|
||||
from marvin.lib.common import list_templates
|
||||
from marvin.lib.utils import cleanup_resources
|
||||
from marvin.cloudstackAPI import startVirtualMachine
|
||||
from marvin.cloudstackAPI import updateTemplate
|
||||
# Import System Modules
|
||||
from nose.plugins.attrib import attr
|
||||
import base64
|
||||
|
||||
|
||||
class TestNuagePasswordReset(nuageTestCase):
|
||||
"""Test user data and password reset functionality with Nuage VSP SDN plugin
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
super(TestNuagePasswordReset, cls).setUpClass()
|
||||
|
||||
return
|
||||
|
||||
def setUp(self):
|
||||
@ -60,16 +63,15 @@ class TestNuagePasswordReset(nuageTestCase):
|
||||
self.vm_1.delete(self.apiclient, expunge=True)
|
||||
if self.remove_vm2:
|
||||
self.vm_2.delete(self.apiclient, expunge=True)
|
||||
|
||||
try:
|
||||
cleanup_resources(self.apiclient, self.cleanup)
|
||||
except Exception as e:
|
||||
self.debug("Warning: Exception during cleanup : %s" % e)
|
||||
self.debug("Warning: Exception during cleanup: %s" % e)
|
||||
return
|
||||
|
||||
# create_template - Takes the VM object as the argument to create the template
|
||||
# create_template - Creates template with the given VM object
|
||||
def create_template(self, vm):
|
||||
self.debug("CREATE TEMPLATE")
|
||||
self.debug("Creating template")
|
||||
list_volume = Volume.list(self.apiclient,
|
||||
virtualmachineid=vm.id,
|
||||
type='ROOT',
|
||||
@ -77,18 +79,31 @@ class TestNuagePasswordReset(nuageTestCase):
|
||||
if isinstance(list_volume, list):
|
||||
self.volume = list_volume[0]
|
||||
else:
|
||||
raise Exception("Exception: Unable to find root volume for VM: %s" % vm.id)
|
||||
|
||||
self.test_data["template_pr"]["ostype"] = self.test_data["ostype_pr"]
|
||||
raise Exception("Exception: Unable to find root volume for VM with ID - %s" % vm.id)
|
||||
self.pw_enabled_template = Template.create(
|
||||
self.apiclient,
|
||||
self.test_data["template_pr"],
|
||||
self.test_data["template"],
|
||||
self.volume.id,
|
||||
account=self.account.name,
|
||||
domainid=self.account.domainid
|
||||
)
|
||||
self.assertEqual(self.pw_enabled_template.passwordenabled, True, "template is not passwordenabled")
|
||||
self.cleanup.append(self.pw_enabled_template)
|
||||
self.debug("Created template")
|
||||
|
||||
# updateTemplate - Updates value of template's password enabled setting
|
||||
def updateTemplate(self, value):
|
||||
self.debug("Updating value of template's password enabled setting")
|
||||
cmd = updateTemplate.updateTemplateCmd()
|
||||
cmd.id = self.template.id
|
||||
cmd.passwordenabled = value
|
||||
self.apiclient.updateTemplate(cmd)
|
||||
list_template_response = list_templates(self.apiclient,
|
||||
templatefilter="all",
|
||||
id=self.template.id
|
||||
)
|
||||
self.template = list_template_response[0]
|
||||
self.debug("Updated template")
|
||||
|
||||
# VM object is passed as an argument and its interface id is returned
|
||||
def get_vm_interface_id(self, vm):
|
||||
@ -109,13 +124,13 @@ class TestNuagePasswordReset(nuageTestCase):
|
||||
|
||||
# Creates and verifies the firewall rule
|
||||
def create_and_verify_fw(self, vm, public_ip, network):
|
||||
self.debug("CREATE AND VERIFY FIREWALL RULE")
|
||||
self.debug("Create and verify firewall rule")
|
||||
self.create_StaticNatRule_For_VM(vm, public_ip, network)
|
||||
|
||||
# VSD verification
|
||||
self.verify_vsp_floating_ip(network, vm, public_ip.ipaddress)
|
||||
|
||||
fw_rule = self.create_firewall_rule(public_ip, self.test_data["ingress_rule"])
|
||||
fw_rule = self.create_FirewallRule(public_ip, self.test_data["ingress_rule"])
|
||||
self.verify_vsp_firewall_rule(fw_rule)
|
||||
vm_interface_id = self.get_vm_interface_id(vm)
|
||||
pd = self.vsd.get_vm_interface_policydecisions(id=vm_interface_id)
|
||||
@ -130,7 +145,7 @@ class TestNuagePasswordReset(nuageTestCase):
|
||||
raise ValueError('No firewall policy decision in vm interface')
|
||||
|
||||
def stop_vm(self, vm):
|
||||
self.debug("STOP VM")
|
||||
self.debug("Stoping VM")
|
||||
vm.stop(self.apiclient)
|
||||
list_vm_response = VirtualMachine.list(self.apiclient,
|
||||
id=vm.id)
|
||||
@ -159,8 +174,10 @@ class TestNuagePasswordReset(nuageTestCase):
|
||||
self.debug("get_set_password_file result " + result)
|
||||
|
||||
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
|
||||
def test_01_UserDataPasswordReset(self):
|
||||
self.debug("START USER DATA PASSWORD RESET ON VM")
|
||||
def test_nuage_UserDataPasswordReset(self):
|
||||
"""Test user data and password reset functionality with Nuage VSP SDN plugin
|
||||
"""
|
||||
|
||||
"""
|
||||
Validate the following:
|
||||
1) user data
|
||||
@ -171,12 +188,12 @@ class TestNuagePasswordReset(nuageTestCase):
|
||||
2. Create an Isolated network - Test Network (10.1.1.1/24).
|
||||
3. Deploy VM1 in Test Network
|
||||
4. Verify domain,zone subnet, vm.
|
||||
5. create public ip , Create Static Nat rule firewall rule and verify
|
||||
5. create public IP, Create Static Nat rule firewall rule and verify
|
||||
6. SSH to VM should be successful
|
||||
7. verify userdata
|
||||
8. check cloud-set-guest-password exist.
|
||||
9. if cloud-set-guest-password exist.
|
||||
9.1 change template password enabled to true
|
||||
9.1 change template password enabled to true
|
||||
9.2 verify that template is password enbalded
|
||||
9.3 SSH with new password should be successful
|
||||
10. else cloud-set-guest-password does not exist.
|
||||
@ -185,27 +202,30 @@ class TestNuagePasswordReset(nuageTestCase):
|
||||
10.3 create a new template with password enabled. Verify that template is password enabled.
|
||||
10.4 create vm 2 with new template in Test Network
|
||||
10.5 Verify vm.
|
||||
10.6 create public ip , Create Static Nat rule firewall rule and verify
|
||||
10.6 create public IP, Create Static Nat rule firewall rule and verify
|
||||
10.7 SSH to VM 2 should be successful
|
||||
11. Reset VM password (VM_1 if guest password file exist. else it is VM2)
|
||||
12 Starting VM and SSH to VM to verify new password
|
||||
"""
|
||||
|
||||
self.debug("TEST USER DATA & PASSWORD RESET ON VM")
|
||||
|
||||
self.defaultTemplateVal = self.template.passwordenabled
|
||||
if self.template.passwordenabled:
|
||||
self.updateTemplate(False)
|
||||
|
||||
self.debug("CREATE AN ISOLATED NETWORK")
|
||||
self.network_1 = self.create_Network(self.test_data["network_offering_pr"])
|
||||
net_off = self.create_NetworkOffering(self.test_data["nuagevsp"]["isolated_network_offering"])
|
||||
self.network_1 = self.create_Network(net_off)
|
||||
self.cleanup.append(self.network_1)
|
||||
expUserData = "hello world vm1"
|
||||
userdata = base64.b64encode(expUserData)
|
||||
self.test_data["virtual_machine_pr"]["userdata"] = userdata
|
||||
self.test_data["virtual_machine_userdata"]["userdata"] = userdata
|
||||
self.debug("DEPLOY VM 1 IN TEST NETWORK")
|
||||
# Pass the network and name of the vm type from the testdata with the configuration for the vm
|
||||
self.vm_1 = self.create_VM_in_Network(self.network_1, "virtual_machine_pr")
|
||||
self.vm_1 = self.create_VM(self.network_1, vm_key="virtual_machine_userdata")
|
||||
|
||||
self.vm_1.password = self.test_data["virtual_machine_pr"]["password"]
|
||||
self.vm_1.password = self.test_data["virtual_machine_userdata"]["password"]
|
||||
user_data_cmd = self.get_userdata_url(self.vm_1)
|
||||
|
||||
# VSD verification
|
||||
@ -214,11 +234,11 @@ class TestNuagePasswordReset(nuageTestCase):
|
||||
self.verify_vsp_vm(self.vm_1)
|
||||
|
||||
self.debug("CREATE PUBLIC IP, STATIC NAT RULE, FLOATING IP, FIREWALL AND VERIFY")
|
||||
public_ip_1 = self.acquire_Public_IP(self.network_1)
|
||||
public_ip_1 = self.acquire_PublicIPAddress(self.network_1)
|
||||
self.create_and_verify_fw(self.vm_1, public_ip_1, self.network_1)
|
||||
|
||||
self.debug("SSH TO VM")
|
||||
ssh = self.ssh_into_vm(self.vm_1, public_ip_1)
|
||||
ssh = self.ssh_into_VM(self.vm_1, public_ip_1)
|
||||
|
||||
self.debug("VERIFY USER DATA")
|
||||
self.debug("Get User Data with command: " + user_data_cmd)
|
||||
@ -238,25 +258,23 @@ class TestNuagePasswordReset(nuageTestCase):
|
||||
self.stop_vm(self.vm_1)
|
||||
self.create_template(self.vm_1)
|
||||
self.debug("DEPLOY VM 2 IN TEST NETWORK WITH NEW TEMPLATE")
|
||||
self.vm_2 = self.create_VM_in_Network(self.network_1, "virtual_machine_pr")
|
||||
self.vm_2 = self.create_VM(self.network_1, vm_key="virtual_machine_userdata")
|
||||
self.remove_vm2 = True
|
||||
self.debug("STARTING VM_2 ")
|
||||
startCmd = startVirtualMachine.startVirtualMachineCmd()
|
||||
startCmd.id = self.vm_2.id
|
||||
vm_2a = self.apiclient.startVirtualMachine(startCmd)
|
||||
vm_2a = self.vm_2.start(self.apiclient)
|
||||
self.vm_2.password = vm_2a.password.strip()
|
||||
self.vm_2.nic = vm_2a.nic
|
||||
self.debug("VM - %s password %s !" % (self.vm_2.name, self.vm_2.password))
|
||||
self.debug("VM - %s password - %s !" % (self.vm_2.name, self.vm_2.password))
|
||||
self.assertNotEqual(self.vm_2.password,
|
||||
self.test_data["virtual_machine_pr"]["password"],
|
||||
self.test_data["virtual_machine_userdata"]["password"],
|
||||
"Password enabled not working. Password same as virtual_machine password "
|
||||
)
|
||||
self.verify_vsp_vm(vm_2a)
|
||||
self.debug("GET PUBLIC IP. CREATE AND VERIFIED FIREWALL RULES")
|
||||
public_ip_2 = self.acquire_Public_IP(self.network_1)
|
||||
public_ip_2 = self.acquire_PublicIPAddress(self.network_1)
|
||||
self.create_and_verify_fw(self.vm_2, public_ip_2, self.network_1)
|
||||
|
||||
ssh = self.ssh_into_vm(self.vm_2, public_ip_2)
|
||||
self.ssh_into_VM(self.vm_2, public_ip_2)
|
||||
vm_test = self.vm_2
|
||||
vm_test_public_ip = public_ip_2
|
||||
|
||||
@ -267,10 +285,10 @@ class TestNuagePasswordReset(nuageTestCase):
|
||||
vm_test = self.vm_1
|
||||
vm_test_public_ip = public_ip_1
|
||||
|
||||
self.debug("RESETTING VM PASSWORD for VM: %s" % vm_test.name)
|
||||
self.debug("RESETTING VM PASSWORD for VM - %s" % vm_test.name)
|
||||
vm_test.password = vm_test.resetPassword(self.apiclient)
|
||||
self.debug("Password reset to: %s" % vm_test.password)
|
||||
self.debug("Password reset to - %s" % vm_test.password)
|
||||
self.debug("STARTING VM AND SSH TO VM TO VERIFY NEW PASSWORD")
|
||||
vm_test.start(self.apiclient)
|
||||
self.debug("VM - %s started!" % vm_test.name)
|
||||
self.ssh_into_vm(vm_test, vm_test_public_ip)
|
||||
self.ssh_into_VM(vm_test, vm_test_public_ip)
|
||||
|
||||
2076
test/integration/plugins/nuagevsp/test_nuage_vpc_internal_lb.py
Normal file
2076
test/integration/plugins/nuagevsp/test_nuage_vpc_internal_lb.py
Normal file
File diff suppressed because it is too large
Load Diff
@ -15,16 +15,17 @@
|
||||
# specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
""" Tests for Basic VPC Network Functionality with NuageVsp network Plugin
|
||||
""" Tests for basic VPC Network functionality with Nuage VSP SDN plugin
|
||||
"""
|
||||
# Import Local Modules
|
||||
from marvin.lib.base import Account
|
||||
from nose.plugins.attrib import attr
|
||||
from nuageTestCase import nuageTestCase
|
||||
from marvin.lib.base import Account
|
||||
# Import System Modules
|
||||
from nose.plugins.attrib import attr
|
||||
|
||||
|
||||
class TestVpcNetworkNuage(nuageTestCase):
|
||||
""" Test Basic VPC Network Functionality with NuageVsp network Plugin
|
||||
""" Test basic VPC Network functionality with Nuage VSP SDN plugin
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
@ -44,55 +45,55 @@ class TestVpcNetworkNuage(nuageTestCase):
|
||||
|
||||
@attr(tags=["advanced", "nuagevsp"], required_hardware="false")
|
||||
def test_nuage_vpc_network(self):
|
||||
""" Test Basic VPC Network Functionality with NuageVsp network Plugin
|
||||
""" Test Basic VPC Network Functionality with Nuage VSP SDN plugin
|
||||
"""
|
||||
|
||||
# 1. Create Nuage VSP VPC offering, check if it is successfully created and enabled.
|
||||
# 2. Create a VPC with Nuage VSP VPC offering, check if it is successfully created and enabled.
|
||||
# 3. Create Nuage Vsp VPC Network offering, check if it is successfully created and enabled.
|
||||
# 3. Create Nuage VSP VPC Network offering, check if it is successfully created and enabled.
|
||||
# 4. Create an ACL list in the created VPC, and add an ACL item to it.
|
||||
# 5. Create a VPC Network with Nuage Vsp VPC Network offering and the created ACL list, check if it is
|
||||
# 5. Create a VPC Network with Nuage VSP VPC Network offering and the created ACL list, check if it is
|
||||
# successfully created, is in the "Implemented" state, and is added to the VPC VR.
|
||||
# 6. Deploy a VM in the created VPC network, check if the VM is successfully deployed and is in the "Running"
|
||||
# state.
|
||||
# 7. Verify that the created ACL item is successfully implemented in Nuage Vsp.
|
||||
# 7. Verify that the created ACL item is successfully implemented in Nuage VSP.
|
||||
|
||||
# Creating a VPC offering
|
||||
self.debug("Creating Nuage VSP VPC offering...")
|
||||
vpc_offering = self.create_VpcOffering(self.test_data["nuage_vsp_services"]["vpc_offering"])
|
||||
self.validate_vpc_offering(vpc_offering, state="Enabled")
|
||||
vpc_offering = self.create_VpcOffering(self.test_data["nuagevsp"]["vpc_offering"])
|
||||
self.validate_VpcOffering(vpc_offering, state="Enabled")
|
||||
|
||||
# Creating a VPC
|
||||
self.debug("Creating a VPC with Nuage VSP VPC offering...")
|
||||
vpc = self.create_Vpc(vpc_offering, cidr='10.1.0.0/16')
|
||||
self.validate_vpc(vpc, state="Enabled")
|
||||
self.validate_Vpc(vpc, state="Enabled")
|
||||
|
||||
# Creating a network offering
|
||||
self.debug("Creating Nuage Vsp VPC Network offering...")
|
||||
network_offering = self.create_NetworkOffering(self.test_data["nuage_vsp_services"]["vpc_network_offering"])
|
||||
self.validate_network_offering(network_offering, state="Enabled")
|
||||
self.debug("Creating Nuage VSP VPC Network offering...")
|
||||
network_offering = self.create_NetworkOffering(self.test_data["nuagevsp"]["vpc_network_offering"])
|
||||
self.validate_NetworkOffering(network_offering, state="Enabled")
|
||||
|
||||
# Creating an ACL list
|
||||
acl_list = self.create_network_acl_list(name="acl", description="acl", vpc=vpc)
|
||||
acl_list = self.create_NetworkAclList(name="acl", description="acl", vpc=vpc)
|
||||
|
||||
# Creating an ACL item
|
||||
acl_item = self.create_network_acl_rule(self.test_data["ingress_rule"], acl_list=acl_list)
|
||||
acl_item = self.create_NetworkAclRule(self.test_data["ingress_rule"], acl_list=acl_list)
|
||||
|
||||
# Creating a VPC network in the VPC
|
||||
self.debug("Creating a VPC network with Nuage Vsp VPC Network offering...")
|
||||
vpc_network = self.create_Network(network_offering, gateway='10.1.1.1', vpc=vpc, acl_list=acl_list)
|
||||
self.validate_network(vpc_network, state="Implemented")
|
||||
vr = self.get_network_router(vpc_network)
|
||||
self.check_router_state(vr, state="Running")
|
||||
self.debug("Creating a VPC network with Nuage VSP VPC Network offering...")
|
||||
vpc_network = self.create_Network(network_offering, vpc=vpc, acl_list=acl_list)
|
||||
self.validate_Network(vpc_network, state="Implemented")
|
||||
vr = self.get_Router(vpc_network)
|
||||
self.check_Router_state(vr, state="Running")
|
||||
|
||||
# Deploying a VM in the VPC network
|
||||
vm = self.create_VM_in_Network(vpc_network)
|
||||
self.check_vm_state(vm, state="Running")
|
||||
vm = self.create_VM(vpc_network)
|
||||
self.check_VM_state(vm, state="Running")
|
||||
|
||||
# VSPK verification
|
||||
# VSD verification
|
||||
self.verify_vsp_network(self.domain.id, vpc_network, vpc)
|
||||
self.verify_vsp_router(vr)
|
||||
self.verify_vsp_vm(vm)
|
||||
|
||||
# VSPK verification for ACL item
|
||||
# VSD verification for ACL item
|
||||
self.verify_vsp_firewall_rule(acl_item)
|
||||
|
||||
@ -15,16 +15,17 @@
|
||||
# specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
""" P1 tests for NuageVsp network Plugin
|
||||
""" P1 tests for Nuage VSP SDN plugin
|
||||
"""
|
||||
# Import Local Modules
|
||||
from marvin.lib.base import Account
|
||||
from nose.plugins.attrib import attr
|
||||
from nuageTestCase import nuageTestCase
|
||||
from marvin.lib.base import Account
|
||||
# Import System Modules
|
||||
from nose.plugins.attrib import attr
|
||||
|
||||
|
||||
class TestNuageVsp(nuageTestCase):
|
||||
""" Test NuageVsp network plugin
|
||||
""" Test Nuage VSP SDN plugin
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
@ -44,12 +45,12 @@ class TestNuageVsp(nuageTestCase):
|
||||
|
||||
@attr(tags=["advanced", "nuagevsp"], required_hardware="false")
|
||||
def test_nuage_vsp(self):
|
||||
""" Test NuageVsp network plugin with basic Isolated Network functionality
|
||||
""" Test Nuage VSP SDN plugin with basic Isolated Network functionality
|
||||
"""
|
||||
|
||||
# 1. Verify that the NuageVsp network service provider is successfully created and enabled.
|
||||
# 2. Create and enable Nuage Vsp Isolated Network offering, check if it is successfully created and enabled.
|
||||
# 3. Create an Isolated Network with Nuage Vsp Isolated Network offering, check if it is successfully created
|
||||
# 1. Verify that the Nuage VSP network service provider is successfully created and enabled.
|
||||
# 2. Create and enable Nuage VSP Isolated Network offering, check if it is successfully created and enabled.
|
||||
# 3. Create an Isolated Network with Nuage VSP Isolated Network offering, check if it is successfully created
|
||||
# and is in the "Allocated" state.
|
||||
# 4. Deploy a VM in the created Isolated network, check if the Isolated network state is changed to
|
||||
# "Implemented", and both the VM & VR are successfully deployed and are in the "Running" state.
|
||||
@ -58,49 +59,49 @@ class TestNuageVsp(nuageTestCase):
|
||||
# 6. Delete the created Isolated Network after destroying its VMs, check if the Isolated network is successfully
|
||||
# deleted.
|
||||
|
||||
self.debug("Validating the NuageVsp network service provider...")
|
||||
self.debug("Validating the Nuage VSP network service provider...")
|
||||
self.validate_NetworkServiceProvider("NuageVsp", state="Enabled")
|
||||
|
||||
# Creating a network offering
|
||||
self.debug("Creating and enabling Nuage Vsp Isolated Network offering...")
|
||||
self.debug("Creating and enabling Nuage VSP Isolated Network offering...")
|
||||
network_offering = self.create_NetworkOffering(
|
||||
self.test_data["nuage_vsp_services"]["isolated_network_offering"])
|
||||
self.validate_network_offering(network_offering, state="Enabled")
|
||||
self.test_data["nuagevsp"]["isolated_network_offering"])
|
||||
self.validate_NetworkOffering(network_offering, state="Enabled")
|
||||
|
||||
# Creating a network
|
||||
self.debug("Creating an Isolated Network with Nuage Vsp Isolated Network offering...")
|
||||
network = self.create_Network(network_offering, gateway='10.1.1.1')
|
||||
self.validate_network(network, state="Allocated")
|
||||
self.debug("Creating an Isolated Network with Nuage VSP Isolated Network offering...")
|
||||
network = self.create_Network(network_offering)
|
||||
self.validate_Network(network, state="Allocated")
|
||||
|
||||
# Deploying a VM in the network
|
||||
vm_1 = self.create_VM_in_Network(network)
|
||||
self.validate_network(network, state="Implemented")
|
||||
vr = self.get_network_router(network)
|
||||
self.check_router_state(vr, state="Running")
|
||||
self.check_vm_state(vm_1, state="Running")
|
||||
vm_1 = self.create_VM(network)
|
||||
self.validate_Network(network, state="Implemented")
|
||||
vr = self.get_Router(network)
|
||||
self.check_Router_state(vr, state="Running")
|
||||
self.check_VM_state(vm_1, state="Running")
|
||||
|
||||
# VSPK verification
|
||||
# VSD verification
|
||||
self.verify_vsp_network(self.domain.id, network)
|
||||
self.verify_vsp_router(vr)
|
||||
self.verify_vsp_vm(vm_1)
|
||||
|
||||
# Deploying one more VM in the network
|
||||
vm_2 = self.create_VM_in_Network(network)
|
||||
self.check_vm_state(vm_2, state="Running")
|
||||
vm_2 = self.create_VM(network)
|
||||
self.check_VM_state(vm_2, state="Running")
|
||||
|
||||
# VSPK verification
|
||||
# VSD verification
|
||||
self.verify_vsp_vm(vm_2)
|
||||
|
||||
# Deleting the network
|
||||
self.debug("Deleting the Isolated Network with Nuage Vsp Isolated Network offering...")
|
||||
self.debug("Deleting the Isolated Network with Nuage VSP Isolated Network offering...")
|
||||
self.delete_VM(vm_1)
|
||||
self.delete_VM(vm_2)
|
||||
self.delete_Network(network)
|
||||
with self.assertRaises(Exception):
|
||||
self.validate_network(network)
|
||||
self.validate_Network(network)
|
||||
self.debug("Isolated Network successfully deleted in CloudStack")
|
||||
|
||||
# VSPK verification
|
||||
# VSD verification
|
||||
with self.assertRaises(Exception):
|
||||
self.verify_vsp_network(self.domain.id, network)
|
||||
self.debug("Isolated Network successfully deleted in VSD")
|
||||
|
||||
@ -735,6 +735,34 @@ test_data = {
|
||||
"publicport": 22,
|
||||
"protocol": 'TCP'
|
||||
},
|
||||
"internal_lbrule": {
|
||||
"name": "SSH",
|
||||
"algorithm": "roundrobin",
|
||||
# Algorithm used for load balancing
|
||||
"sourceport": 22,
|
||||
"instanceport": 22,
|
||||
"scheme": "internal",
|
||||
"protocol": "TCP",
|
||||
"cidrlist": '0.0.0.0/0',
|
||||
},
|
||||
"internal_lbrule_http": {
|
||||
"name": "HTTP",
|
||||
"algorithm": "roundrobin",
|
||||
# Algorithm used for load balancing
|
||||
"sourceport": 80,
|
||||
"instanceport": 80,
|
||||
"scheme": "internal",
|
||||
"protocol": "TCP",
|
||||
"cidrlist": '0.0.0.0/0',
|
||||
},
|
||||
"http_rule": {
|
||||
"privateport": 80,
|
||||
"publicport": 80,
|
||||
"startport": 80,
|
||||
"endport": 80,
|
||||
"protocol": "TCP",
|
||||
"cidrlist": '0.0.0.0/0',
|
||||
},
|
||||
"icmprule": {
|
||||
"icmptype": -1,
|
||||
"icmpcode": -1,
|
||||
@ -1696,9 +1724,9 @@ test_data = {
|
||||
"mode": 'HTTP_DOWNLOAD'
|
||||
}
|
||||
},
|
||||
# Nuage Vsp supported services
|
||||
"nuage_vsp_services": {
|
||||
# Services supported by Nuage Vsp for Isolated networks
|
||||
# Nuage VSP SDN plugin specific test data
|
||||
"nuagevsp": {
|
||||
# Services supported by the Nuage VSP plugin for Isolated networks
|
||||
"isolated_network_offering": {
|
||||
"name": 'nuage_marvin',
|
||||
"displaytext": 'nuage_marvin',
|
||||
@ -1718,7 +1746,7 @@ test_data = {
|
||||
"SourceNat": {"SupportedSourceNatTypes": "perzone"}
|
||||
}
|
||||
},
|
||||
# Services supported by Nuage Vsp for VPC networks
|
||||
# Services supported by the Nuage VSP plugin for VPC networks
|
||||
"vpc_network_offering": {
|
||||
"name": 'nuage_vpc_marvin',
|
||||
"displaytext": 'nuage_vpc_marvin',
|
||||
@ -1740,7 +1768,30 @@ test_data = {
|
||||
"SourceNat": {"SupportedSourceNatTypes": "perzone"}
|
||||
}
|
||||
},
|
||||
# Nuage Vsp supports only pre-defined and custom VPC offerings
|
||||
"vpc_network_offering_internal_lb": {
|
||||
"name": "nuage_vpc_marvin_internal_lb",
|
||||
"displaytext": "nuage_vpc_marvin_internal_lb",
|
||||
"guestiptype": 'Isolated',
|
||||
"supportedservices": 'Dhcp,Lb,StaticNat,SourceNat,NetworkACL,Connectivity,UserData',
|
||||
"traffictype": 'GUEST',
|
||||
"availability": 'Optional',
|
||||
"useVpc": 'on',
|
||||
"ispersistent": 'True',
|
||||
"serviceProviderList": {
|
||||
"Dhcp": "NuageVsp",
|
||||
"Lb": "InternalLbVm",
|
||||
"StaticNat": "NuageVsp",
|
||||
"SourceNat": "NuageVsp",
|
||||
"NetworkACL": "NuageVsp",
|
||||
"Connectivity": "NuageVsp",
|
||||
"UserData": "VpcVirtualRouter"
|
||||
},
|
||||
"serviceCapabilityList": {
|
||||
"SourceNat": {"SupportedSourceNatTypes": "perzone"},
|
||||
"Lb": {"lbSchemes": "internal", "SupportedLbIsolation": "dedicated"}
|
||||
}
|
||||
},
|
||||
# Services supported by the Nuage VSP plugin for VPCs
|
||||
"vpc_offering": {
|
||||
"name": 'Nuage VSP VPC offering',
|
||||
"displaytext": 'Nuage VSP VPC offering',
|
||||
@ -1753,57 +1804,20 @@ test_data = {
|
||||
"Connectivity": "NuageVsp",
|
||||
"UserData": "VpcVirtualRouter"
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
#_pr -_ passwordreset - below services used in test_nuage_password_reset
|
||||
"network_offering_pr": {
|
||||
"name": 'nuage_marvin',
|
||||
"displaytext": 'nuage_marvin',
|
||||
"guestiptype": 'Isolated',
|
||||
"supportedservices":
|
||||
'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall',
|
||||
"traffictype": 'GUEST',
|
||||
"availability": 'Optional',
|
||||
"serviceProviderList": {
|
||||
"UserData": 'VirtualRouter',
|
||||
"Dhcp": 'NuageVsp',
|
||||
"Connectivity": 'NuageVsp',
|
||||
"StaticNat": 'NuageVsp',
|
||||
"SourceNat": 'NuageVsp',
|
||||
"Firewall": 'NuageVsp'
|
||||
},
|
||||
},
|
||||
"network_pr": {
|
||||
"name": "Test Network",
|
||||
"displaytext": "Test Network",
|
||||
"netmask": '255.255.255.0'
|
||||
},
|
||||
"fw_rule_pr": {
|
||||
"startport": 1,
|
||||
"endport": 6000,
|
||||
"cidr": '0.0.0.0/0',
|
||||
# Any network (For creating FW rule)
|
||||
"protocol": "TCP"
|
||||
},
|
||||
"virtual_machine_pr": {
|
||||
"displayname": "Test VM",
|
||||
"username": "root",
|
||||
"password": "password",
|
||||
"ssh_port": 22,
|
||||
"hypervisor": 'kvm',
|
||||
# Hypervisor type should be same as
|
||||
# hypervisor type of cluster
|
||||
"privateport": 22,
|
||||
"publicport": 22,
|
||||
"protocol": 'TCP',
|
||||
"userdata": "This is sample data",
|
||||
},
|
||||
"template_pr": {
|
||||
"displaytext": "Cent OS Template",
|
||||
"name": "Cent OS Template",
|
||||
"passwordenabled": True,
|
||||
},
|
||||
"ostype_pr": 'CentOS 5.5 (64-bit)',
|
||||
|
||||
"vpc_offering_lb": {
|
||||
"name": 'Nuage VSP VPC offering with Lb',
|
||||
"displaytext": 'Nuage VSP VPC offering with Lb',
|
||||
"supportedservices": 'Dhcp,Lb,StaticNat,SourceNat,NetworkACL,Connectivity,UserData',
|
||||
"serviceProviderList": {
|
||||
"Dhcp": "NuageVsp",
|
||||
"Lb": "InternalLbVm",
|
||||
"StaticNat": "NuageVsp",
|
||||
"SourceNat": "NuageVsp",
|
||||
"NetworkACL": "NuageVsp",
|
||||
"Connectivity": "NuageVsp",
|
||||
"UserData": "VpcVirtualRouter"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -4673,7 +4673,7 @@ class ApplicationLoadBalancer:
|
||||
@classmethod
|
||||
def create(cls, apiclient, services, name=None, sourceport=None,
|
||||
instanceport=22, algorithm="roundrobin", scheme="internal",
|
||||
sourcenetworkid=None, networkid=None):
|
||||
sourcenetworkid=None, networkid=None, sourceipaddress=None):
|
||||
"""Create Application Load Balancer"""
|
||||
cmd = createLoadBalancer.createLoadBalancerCmd()
|
||||
|
||||
@ -4712,6 +4712,11 @@ class ApplicationLoadBalancer:
|
||||
elif networkid:
|
||||
cmd.networkid = networkid
|
||||
|
||||
if "sourceipaddress" in services:
|
||||
cmd.sourceipaddress = services["sourceipaddress"]
|
||||
elif sourceipaddress:
|
||||
cmd.sourceipaddress = sourceipaddress
|
||||
|
||||
return LoadBalancerRule(apiclient.createLoadBalancer(cmd).__dict__)
|
||||
|
||||
def delete(self, apiclient):
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user