apache/cloudstack
1
0
Fork 0
mirror of https://github.com/apache/cloudstack.git synced 2025-11-02 20:02:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add nuagevsp userdata testcase (Cloudstack-9095) & Refactor existing testcases

Browse Source
This commit is contained in:
Sowmya 2016-03-08 18:13:24 -08:00
parent 359d20e8d6
commit 3c8d3d0ee1
7 changed files with 1448 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

334
test/integration/component/test_nuage_vsp.py
View File

@ -1,334 +0,0 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
""" P1 tests for NuageVsp network Plugin
"""
# Import Local Modules
from nose.plugins.attrib import attr
from marvin.cloudstackTestCase import cloudstackTestCase
from marvin.cloudstackAPI import (listPhysicalNetworks,
listNetworkServiceProviders,
addNetworkServiceProvider,
deleteNetworkServiceProvider,
deleteNuageVspDevice,
updateNetworkServiceProvider,
addNuageVspDevice,
destroyVirtualMachine)
from marvin.lib.utils import (cleanup_resources)
from marvin.lib.base import (Account,
VirtualMachine,
ServiceOffering,
NetworkOffering,
Network)
from marvin.lib.common import (get_domain,
get_zone,
get_template)
import logging
import unittest
class Services:
"""Test NuageVsp plugin
"""
def __init__(self):
print "in __init__"
self.services = {
"account": {
"email": "cloudstack@cloudmonkey.com",
"firstname": "cloudstack",
"lastname": "bob",
"username": "admin",
"password": "password",
},
"service_offering": {
"name": "Tiny Instance",
"displaytext": "Tiny Instance",
"cpunumber": 1,
"cpuspeed": 100, # in MHz
"memory": 128, # In MBs
},
"virtual_machine": {
"displayname": "TestVM",
"username": "root",
"password": "password",
"ssh_port": 22,
"hypervisor": 'KVM',
"privateport": 22,
"publicport": 22,
"protocol": 'TCP',
},
"nuage_vsp_device": {
"hostname": '172.31.222.162',
"username": 'cloudstackuser1',
"password": 'cloudstackuser1',
"port": '8443',
"apiversion": 'v3_2',
"retrycount": '4',
"retryinterval": '60'
},
# services supported by Nuage for isolated networks.
"network_offering": {
"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'
},
"serviceCapabilityList": {
"SourceNat": {"SupportedSourceNatTypes": "perzone"},
}
},
"network": {
"name": "nuage",
"displaytext": "nuage",
},
"ostype": 'CentOS 5.5 (64-bit)',
"sleep": 60,
"timeout": 10
}
class TestNuageVsp(cloudstackTestCase):
@classmethod
def setUpClass(cls):
print "In setup class"
cls._cleanup = []
cls.testClient = super(TestNuageVsp, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = Services().services
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.template = get_template(
cls.api_client,
cls.zone.id,
cls.services["ostype"]
)
# nuage vsp device brings the Nuage virtual service platform into play
cls.nuage_services = cls.services["nuage_vsp_device"]
try:
resp = listPhysicalNetworks.listPhysicalNetworksCmd()
print "in cls.setupClass- resp: %s" % resp
resp.zoneid = cls.zone.id
physical_networks = cls.api_client.listPhysicalNetworks(resp)
for pn in physical_networks:
if pn.isolationmethods=='VSP':
physical_network = pn
#if isinstance(physical_networks, list):
# physical_network = physical_networks[1]
resp = listNetworkServiceProviders.listNetworkServiceProvidersCmd()
resp.name = 'NuageVsp'
resp.physicalnetworkid = physical_network.id
nw_service_providers = cls.api_client.listNetworkServiceProviders(
resp)
if not isinstance(nw_service_providers, list):
# create network service provider and add nuage vsp device
resp_add_nsp =\
addNetworkServiceProvider.addNetworkServiceProviderCmd()
resp_add_nsp.name = 'NuageVsp'
resp_add_nsp.physicalnetworkid = physical_network.id
cls.api_client.addNetworkServiceProvider(resp_add_nsp)
#Get NSP ID
nw_service_providers = cls.api_client.listNetworkServiceProviders(
resp)
cls.debug("NuageVsp NSP ID: %s" % nw_service_providers[0].id)
resp_add_device = addNuageVspDevice.addNuageVspDeviceCmd()
resp_add_device.physicalnetworkid = physical_network.id
resp_add_device.username = cls.nuage_services["username"]
resp_add_device.password = cls.nuage_services["password"]
resp_add_device.hostname = cls.nuage_services["hostname"]
resp_add_device.port = cls.nuage_services["port"]
resp_add_device.apiversion = cls.nuage_services[
"apiversion"]
resp_add_device.retrycount = cls.nuage_services[
"retrycount"]
resp_add_device.retryinterval = cls.nuage_services[
"retryinterval"]
cls.nuage = cls.api_client.addNuageVspDevice(
resp_add_device)
#Enable NuageVsp NSP
cls.debug("NuageVsp NSP ID : %s" % nw_service_providers[0].id)
resp_up_nsp = \
updateNetworkServiceProvider.updateNetworkServiceProviderCmd()
resp_up_nsp.id = nw_service_providers[0].id
resp_up_nsp.state = 'Enabled'
cls.api_client.updateNetworkServiceProvider(resp_up_nsp)
cls.network_offering = NetworkOffering.create(
cls.api_client,
cls.services["network_offering"],
conservemode=True
)
cls._cleanup.append(cls.network_offering)
cls.network_offering.update(cls.api_client, state='Enabled')
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.service_offering = ServiceOffering.create(
cls.api_client,
cls.services["service_offering"]
)
cls._cleanup.append(cls.service_offering)
except Exception as e:
cls.tearDownClass()
raise unittest.SkipTest("Unable to add VSP device")
return
@classmethod
def tearDownClass(cls):
try:
cleanup_resources(cls.api_client, cls._cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.account = Account.create(
self.apiclient,
self.services["account"],
admin=True,
domainid=self.domain.id
)
self.cleanup = [self.account]
return
def tearDown(self):
try:
self.debug("Cleaning up the resources")
cleanup_resources(self.apiclient, self.cleanup)
self.debug("Cleanup complete!")
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
@attr(tags=["advanced"])
def test_network_vsp(self):
"""Test nuage Network and VM Creation
"""
self.debug("Creating network with network offering: %s" %
self.network_offering.id)
self.network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id,
gateway = "10.1.1.1",
netmask = '255.255.255.0'
)
self.debug("Created network with ID: %s" % self.network.id)
self.debug("Deploying VM in account: %s" % self.account.name)
virtual_machine_1 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(self.network.id)]
)
self.debug("Deployed VM in network: %s" % self.network.id)
list_vm_response = VirtualMachine.list(
self.apiclient,
id=virtual_machine_1.id
)
self.debug(
"Verify listVirtualMachines response for virtual machine: %s"
% virtual_machine_1.id
)
self.assertEqual(
isinstance(list_vm_response, list),
True,
"Check list response returns a valid list"
)
vm_response = list_vm_response[0]
self.assertEqual(
vm_response.state,
"Running",
"VM state should be running after deployment"
)
self.debug("Deploying another VM in account: %s" %
self.account.name)
virtual_machine_2 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(self.network.id)]
)
self.debug("Deployed VM in network: %s" % self.network.id)
list_vm_response = VirtualMachine.list(
self.apiclient,
id=virtual_machine_2.id
)
self.debug(
"Verify listVirtualMachines response for virtual machine: %s"
% virtual_machine_2.id
)
self.assertEqual(
isinstance(list_vm_response, list),
True,
"Check list response returns a valid list"
)
vm_response = list_vm_response[0]
self.assertEqual(
vm_response.state,
"Running",
"VM state should be running after deployment"
)
VirtualMachine.delete(virtual_machine_1, self.apiclient, expunge=True)
# # Deleting a single VM
VirtualMachine.delete(virtual_machine_2, self.apiclient, expunge=True)
# Delete Network
Network.delete(self.network, self.apiclient)
return

830
test/integration/plugins/nuagevsp/nuageTestCase.py Normal file
View File

@ -0,0 +1,830 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
""" Custom base class for NuageVsp network 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,
FireWallRule,
EgressFireWallRule,
Host)
from marvin.lib.common import (get_zone,
get_domain,
get_template,
list_templates,
wait_for_cleanup)
from marvin.lib.utils import cleanup_resources
from marvin.cloudstackAPI import (listPhysicalNetworks,
updateConfiguration,
updateTemplate,
listConfigurations,
listHypervisors,
stopRouter,
startRouter)
# Import nosetests Modules
from nose.plugins.attrib import attr
# Import System Modules
import socket
import importlib
import logging
class nuageTestCase(cloudstackTestCase):
@classmethod
def setUpClass(cls):
cls.debug("setUpClass nuageTestCase")
# We want to fail quicker, if it's a failure
socket.setdefaulttimeout(60)
test_client = super(nuageTestCase, cls).getClsTestClient()
cls.api_client = test_client.getApiClient()
cls.db_client = test_client.getDbConnection()
cls.test_data = test_client.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.zone = get_zone(cls.api_client)
cls.domain = get_domain(cls.api_client)
cls.template = get_template(cls.api_client,
cls.zone.id,
cls.test_data["ostype"]
)
cls.test_data["virtual_machine"]["zoneid"] = cls.zone.id
cls.test_data["virtual_machine"]["template"] = cls.template.id
# Create service offering
cls.service_offering = ServiceOffering.create(cls.api_client,
cls.test_data["service_offering"]
)
cls._cleanup = [cls.service_offering]
# Get configured Nuage Vsp device details
try:
resp = listPhysicalNetworks.listPhysicalNetworksCmd()
resp.zoneid = cls.zone.id
physical_networks = cls.api_client.listPhysicalNetworks(resp)
for pn in physical_networks:
if pn.isolationmethods == 'VSP':
cls.vsp_physical_network = pn
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
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]
except Exception as e:
cls.tearDownClass()
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'
# VSD is a Python SDK for Nuage Vsp
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)
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)
set_log_level = getattr(vsdk_utils, "set_log_level")
from cms_vspk_wrapper.cms_vspk_wrapper import Cms_vspk_wrapper
except:
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.start()
# Configure cms_vspk_wrapper session
cls.log_handler = logging.getLogger("CSLog").handlers[0]
vsd_info = cls.nuage_vsp_device.__dict__
vsd_info["port"] = str(vsd_info["port"])
cls.vsd = Cms_vspk_wrapper(vsd_info, cls.log_handler)
set_log_level(logging.INFO)
cls.debug("setUpClass nuageTestCase [DONE]")
def setUp(self):
self.cleanup = []
return
@classmethod
def tearDownClass(cls):
try:
# Cleanup resources used
cleanup_resources(cls.api_client, cls._cleanup)
except Exception as e:
cls.debug("Warning: Exception during cleanup : %s" % e)
return
def tearDown(self):
# Cleanup resources used
self.debug("Cleaning up the resources")
for obj in reversed(self.cleanup):
try:
if isinstance(obj, VirtualMachine):
obj.delete(self.api_client, expunge=True)
else:
obj.delete(self.api_client)
except Exception as e:
self.error("Failed to cleanup %s, got %s" % (obj, e))
# cleanup_resources(self.api_client, self.cleanup)
self.cleanup = []
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
def create_VpcOffering(self, vpc_offering, suffix=None):
self.debug('Create VpcOffering')
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')
self.cleanup.append(vpc_off)
self.debug('Created and Enabled VpcOffering')
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)
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)
if cleanup:
self.cleanup.append(vpc)
return vpc
# create_NetworkOffering - Takes the network offering as argument and creates the Network Offering
def create_NetworkOffering(self, net_offering, suffix=None, conserve_mode=False):
self.debug('Create NetworkOffering')
if suffix:
net_offering["name"] = "NET_OFF-" + str(suffix)
nw_off = NetworkOffering.create(self.api_client,
net_offering,
conservemode=conserve_mode
)
# Enable Network offering
nw_off.update(self.api_client, state='Enabled')
self.cleanup.append(nw_off)
self.debug('Created and Enabled NetworkOffering')
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
# 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)
# 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"]
)
network.delete(self.api_client)
if network in self.cleanup:
self.cleanup.remove(network)
self.debug('Deleted Network - %s' % network.name)
# 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)
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))
self.cleanup.append(vm)
return vm
# starts the given vm
def start(self, apiclient):
"""Start the instance"""
cmd = startVirtualMachine.startVirtualMachineCmd()
cmd.id = self.id
apiclient.startVirtualMachine(cmd)
response = self.getState(apiclient, VirtualMachine.RUNNING)
if response[0] == FAIL:
raise Exception(response[1])
return
# stops the given vm
def stop(self, apiclient, forced=None):
"""Stop the instance"""
cmd = stopVirtualMachine.stopVirtualMachineCmd()
cmd.id = self.id
if forced:
cmd.forced = forced
apiclient.stopVirtualMachine(cmd)
response = self.getState(apiclient, VirtualMachine.STOPPED)
if response[0] == FAIL:
raise Exception(response[1])
return
# 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"]
)
if vm in self.cleanup:
self.cleanup.remove(vm)
self.debug('Deleted VM - %s' % vm.name)
# 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)
routers = Router.list(self.api_client,
networkid=network.id,
listall=True
)
self.assertEqual(isinstance(routers, list), True,
"List routers should return a valid virtual router for network"
)
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)
# 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)
# 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))
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)
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)
else:
self.debug("ssh execute cmd result is None")
return ret_data
# wget_from_server - fetches the index.html file from 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
# validate_NetworkServiceProvider - Validates the Network Service Provider
# in the Nuage VSP Physical Network - matches the given provider name
# 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 ?")
providers = NetworkServiceProvider.list(self.api_client,
name=provider_name,
physicalnetworkid=self.vsp_physical_network.id)
self.assertEqual(isinstance(providers, list), True,
"List Network Service Provider should return a valid list"
)
self.assertEqual(provider_name, providers[0].name,
"Name of the Network Service Provider should match with the returned list data"
)
if state:
self.assertEqual(providers[0].state, state,
"Network Service Provider state should be '%s'" % state
)
self.debug("Network Service Provider creation successfully validated - %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):
"""Validates the VPC offering"""
self.debug("Check if the VPC offering is created successfully ?")
vpc_offs = VpcOffering.list(self.api_client,
id=vpc_offering.id
)
self.assertEqual(isinstance(vpc_offs, list), True,
"List VPC offering should return a valid list"
)
self.assertEqual(vpc_offering.name, vpc_offs[0].name,
"Name of the VPC offering should match with the returned list data"
)
if state:
self.assertEqual(vpc_offs[0].state, state,
"VPC offering state should be '%s'" % state
)
self.debug("VPC offering creation successfully validated - %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):
"""Validates the VPC"""
self.debug("Check if the VPC is created successfully ?")
vpcs = VPC.list(self.api_client,
id=vpc.id
)
self.assertEqual(isinstance(vpcs, list), True,
"List VPC should return a valid list"
)
self.assertEqual(vpc.name, vpcs[0].name,
"Name of the VPC should match with the returned list data"
)
if state:
self.assertEqual(vpcs[0].state, state,
"VPC state should be '%s'" % state
)
self.debug("VPC creation successfully validated - %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):
"""Validates the Network offering"""
self.debug("Check if the Network offering is created successfully ?")
net_offs = NetworkOffering.list(self.api_client,
id=net_offering.id
)
self.assertEqual(isinstance(net_offs, list), True,
"List Network offering should return a valid list"
)
self.assertEqual(net_offering.name, net_offs[0].name,
"Name of the Network offering should match with the returned list data"
)
if state:
self.assertEqual(net_offs[0].state, state,
"Network offering state should be '%s'" % state
)
self.debug("Network offering creation successfully validated - %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"""
self.debug("Check if the network is created successfully ?")
networks = Network.list(self.api_client,
id=network.id
)
self.assertEqual(isinstance(networks, list), True,
"List network should return a valid list"
)
self.assertEqual(network.name, networks[0].name,
"Name of the network should match with with the returned list data"
)
if state:
self.assertEqual(networks[0].state, state,
"Network state should be '%s'" % state
)
self.debug("Network creation successfully validated - %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):
self.debug("Check if the VM instance is in state - %s" % state)
vms = VirtualMachine.list(self.api_client,
id=vm.id,
listall=True
)
self.assertEqual(isinstance(vms, list), True,
"List virtual machine should return a valid list"
)
if state:
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)
# 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 ?")
public_ips = PublicIPAddress.list(self.api_client,
id=public_ip.ipaddress.id,
networkid=network.id,
isstaticnat=static_nat,
listall=True
)
self.assertEqual(isinstance(public_ips, list), True,
"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"
)
self.assertEqual(public_ips[0].state, "Allocated",
"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"
)
self.debug("Assigned Public IP is successfully validated - %s" % public_ip.ipaddress.ipaddress)
# VSD verifications
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.
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)
:param fetcher: VSPK Fetcher to use to find the child entity
:param cs_objects: Cloudstack objects to take the UUID from.
:return: the VSPK object having the correct externalID
"""
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
def verify_vsp_network(self, domain_id, network, vpc=None):
vsd_enterprise = self.vsd.get_enterprise(name=domain_id)
if vpc:
ext_network_id = self.get_externalID(vpc.id)
else:
ext_network_id = self.get_externalID(network.id)
ext_subnet_id = self.get_externalID(network.id)
vsd_domain = self.vsd.get_domain(externalID=ext_network_id)
vsd_zone = self.vsd.get_zone(externalID=ext_network_id)
vsd_subnet = self.vsd.get_subnet(externalID=ext_subnet_id)
self.debug("SHOW ENTERPRISE DATA FORMAT IN VSD")
self.debug(vsd_enterprise)
self.assertNotEqual(vsd_enterprise, None,
"VSD Enterprise data format should not be a None type"
)
self.debug("SHOW NETWORK DATA FORMAT IN VSD")
self.debug(vsd_domain)
self.debug(vsd_zone)
self.debug(vsd_subnet)
if vpc:
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,
"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_zone['description'], network.name,
"VSD zone description should match Isolated Network name in CloudStack"
)
self.assertEqual(vsd_subnet['description'], network.name,
"VSD subnet description should match Isolated 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
def verify_vsp_vm(self, vm, stopped=None):
ext_vm_id = self.get_externalID(vm.id)
for nic in vm.nic:
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)
vsd_vm_interface = self.vsd.get_vm_interface(externalID=ext_nic_id)
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,
"VSD VM vport should be active"
)
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)
self.debug("SHOW VM DATA FORMAT IN VSD")
self.debug(vsd_vm)
if not self.isSimulator:
if stopped:
self.assertEqual(vsd_vm['status'], "DELETE_PENDING",
"VM state in VSD should be DELETE_PENDING"
)
else:
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
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)
self.debug("SHOW VIRTUAL ROUTER DATA FORMAT IN VSD")
self.debug(vsd_router)
if not self.isSimulator:
if stopped:
self.assertEqual(vsd_router['status'], "DELETE_PENDING",
"Router state in VSD should be DELETE_PENDING"
)
else:
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
def verify_vsp_floating_ip(self, network, vm, public_ipaddress, vpc=None):
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"
)
if vpc:
ext_network_id = self.get_externalID(vpc.id)
else:
ext_network_id = self.get_externalID(network.id)
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'],
"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"
)
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']:
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'],
"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"
)
# verify_vsp_firewall_rule - Verifies the start port, destination port,
# protocol of the given firewall rule Ingress/Egress against the VSD
# firewall rule
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":
vsd_fw_rule = self.vsd.get_egress_acl_entry(externalID=ext_fw_id)
else:
vsd_fw_rule = self.vsd.get_ingress_acl_entry(externalID=ext_fw_id)
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"
)
vsd_protocol = str(vsd_fw_rule['protocol'])
self.debug("vsd protocol " + vsd_protocol)
protocol = "tcp"
if vsd_protocol == 6:
protocol = "tcp"
elif vsd_protocol == 1:
protocol = "icmp"
elif vsd_protocol == 17:
protocol = "udp"
self.assertEqual(protocol, firewall_rule.protocol.lower(),
"Protocol in VSD should match Protocol in CloudStack"
)

249
test/integration/plugins/nuagevsp/test_nuage_password_reset.py Normal file
View File

@ -0,0 +1,249 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
""" Component tests for - userdata
"""
# Import Local Modules
from marvin.lib.base import (VirtualMachine,
Account,
PublicIPAddress)
from nose.plugins.attrib import attr
from nuageTestCase import nuageTestCase
from marvin.cloudstackAPI import (createTemplate,
listVolumes)
import base64
class TestNuagePasswordReset(nuageTestCase):
@classmethod
def setUpClass(cls):
super(TestNuagePasswordReset, cls).setUpClass()
return
def setUp(self):
self.cleanup = []
self.apiclient = self.testClient.getApiClient()
self.account = Account.create(
self.apiclient,
self.test_data["account"],
admin=True,
domainid=self.domain.id
)
self.cleanup.append(self.account)
self.remove_vm2 = False
return
# tearDown() - Cleans up the setup, removes the VMs
def tearDown(self):
self.debug("CLEANUP: TEARDOWN")
self.apiclient = self.testClient.getApiClient()
self.updateTemplate(self.defaultTemplateVal)
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)
return
# create_template - Takes the VM object as the argument to create the template
def create_template(self, vm):
self.debug("CREATE TEMPLATE")
list_volume = list_volumes(
self.apiclient,
virtualmachineid=vm.id,
type='ROOT',
listall=True
)
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"]
self.pw_enabled_template = Template.create(
self.apiclient,
self.test_data["template_pr"],
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)
# VM object is passed as an argument and its interface id is returned
def get_vm_interface_id(self, vm):
self.debug("GET VM INTERFACE ID")
nic_ext_id = self.get_externalID(vm.nic[0].id)
vm_interface = self.vsd.get_vm_interface(externalID=nic_ext_id)
vm_interface_id = vm_interface["ID"]
return vm_interface_id
# VM object is passed as an argument and its userdata URL is returned
def get_userdata_url(self, vm):
self.debug("GET USER DATA URL")
nic = vm.nic[0]
gateway = str(nic.gateway)
self.debug("GATEWAY: " + gateway)
user_data_url = 'curl "http://' + gateway + ':80/latest/user-data"'
return user_data_url
# Creates and verifies the firewall rule
def create_and_verify_fw(self, vm, public_ip, network):
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)
vm_public_ip = public_ip.ipaddress.ipaddress
fw_rule = self.create_firewall_rule(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)
self.debug(pd)
egressAcls = pd['egressACLs'][0]['entries']
gotFirewallPolicy = False
for acl in egressAcls:
if acl['destinationPort'] == "22-22":
gotFirewallPolicy = True
break
if not gotFirewallPolicy:
raise ValueError('No firewall policy decision in vm interface')
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
def test_01_UserDataPasswordReset(self):
self.debug("START USER DATA PASSWORD RESET ON VM")
"""
Validate the following:
1) user data
2) reset vm password.
Steps:
1. Set password enabled to false in the template.
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
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.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.
10.1 get the cloud-set-guest-password file
10.2 stop vm
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.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.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"])
self.cleanup.append(self.network_1)
expUserData = "hello world vm1"
userdata = base64.b64encode(expUserData)
self.test_data["virtual_machine_pr"]["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.password = self.test_data["virtual_machine_pr"]["password"]
user_data_cmd = self.get_userdata_url(self.vm_1)
# VSD verification
self.debug("VERIFY DOMAIN, ZONE, NETWORK , and VM 1")
self.verify_vsp_network(self.domain.id, self.network_1)
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)
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)
self.debug("VERIFY USER DATA")
self.debug("Get User Data with command: " + user_data_cmd)
adata = self.execute_cmd(ssh, user_data_cmd)
actUserData = base64.b64decode(adata)
self.debug("Response User Data=" + actUserData + ", Expected=" + expUserData)
self.assertEqual(actUserData, expUserData, "User Data Did Not Match ")
# check /etc/init.d/cloud-set-quest-password
ls_cmd = "ls /etc/init.d/cloud-set-guest-password"
ls_result = self.execute_cmd(ssh, ls_cmd)
ls_result = ls_result.lower()
self.debug("reponse from ls_cmd: " + ls_result)
if "no such file" in ls_result:
self.debug("NO CLOUD-SET_GUEST_PASSWORD FILE. NEED TO GET ONE")
self.install_cloud_set_guest_password_script(ssh)
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_1 = self.create_VM_in_Network(self.network_1, "virtual_machine_pr")
self.remove_vm2 = True
self.debug("STARTING VM_2 ")
startCmd = startVirtualMachine.startVirtualMachineCmd()
startCmd.id = self.vm_2.id
vm_2a = self.apiclient.startVirtualMachine(startCmd)
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.assertNotEqual(self.vm_2.password,
self.test_data["virtual_machine_pr"]["password"],
"Password enabled not working. Password same as virtual_machine password "
)
self.verify_vsp_vm(vm_2a)
self.debug("GET PUBLIC IP, CREATE AND VERIFY FIREWALL RULES")
public_ip_2 = self.acquire_Public_IP(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)
vm_test = self.vm_2
vm_test_public_ip = public_ip_2
else:
self.debug("UPDATE TEMPLATE TO PASSWORD ENABLED")
self.updateTemplate(True)
self.assertEqual(self.template.passwordenabled, True, "Template is not password enabled")
vm_test = self.vm_1
vm_test_public_ip = public_ip_1
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("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)

98
test/integration/plugins/nuagevsp/test_nuage_vpc_network.py Normal file
View File

@ -0,0 +1,98 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
""" Tests for Basic VPC Network Functionality with NuageVsp network Plugin
"""
# Import Local Modules
from marvin.lib.base import Account
from nose.plugins.attrib import attr
from nuageTestCase import nuageTestCase
class TestVpcNetworkNuage(nuageTestCase):
""" Test Basic VPC Network Functionality with NuageVsp network Plugin
"""
@classmethod
def setUpClass(cls):
super(TestVpcNetworkNuage, cls).setUpClass()
return
def setUp(self):
# Create an account
self.account = Account.create(self.api_client,
self.test_data["account"],
admin=True,
domainid=self.domain.id
)
self.cleanup = [self.account]
return
@attr(tags=["advanced", "nuagevsp"], required_hardware="false")
def test_nuage_vpc_network(self):
""" Test Basic VPC Network Functionality with NuageVsp network 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.
# 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
# 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.
# 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")
# 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")
# 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")
# Creating an ACL list
acl_list = self.create_network_acl_list(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)
# 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")
# Deploying a VM in the VPC network
vm = self.create_VM_in_Network(vpc_network)
self.check_vm_state(vm, state="Running")
# VSPK 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
self.verify_vsp_firewall_rule(acl_item)

106
test/integration/plugins/nuagevsp/test_nuage_vsp.py Normal file
View File

@ -0,0 +1,106 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
""" P1 tests for NuageVsp network Plugin
"""
# Import Local Modules
from marvin.lib.base import Account
from nose.plugins.attrib import attr
from nuageTestCase import nuageTestCase
class TestNuageVsp(nuageTestCase):
""" Test NuageVsp network plugin
"""
@classmethod
def setUpClass(cls):
super(TestNuageVsp, cls).setUpClass()
return
def setUp(self):
# Create an account
self.account = Account.create(self.api_client,
self.test_data["account"],
admin=True,
domainid=self.domain.id
)
self.cleanup = [self.account]
return
@attr(tags=["advanced", "nuagevsp"], required_hardware="false")
def test_nuage_vsp(self):
""" Test NuageVsp network 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
# 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.
# 5. Deploy one more VM in the created Isolated network, check if the VM is successfully deployed and is in the
# "Running" state.
# 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.validate_NetworkServiceProvider("NuageVsp", state="Enabled")
# Creating a 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")
# 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")
# 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")
# VSPK 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")
# VSPK verification
self.verify_vsp_vm(vm_2)
# Deleting the network
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.debug("Isolated Network successfully deleted in CloudStack")
# VSPK verification
with self.assertRaises(Exception):
self.verify_vsp_network(self.domain.id, network)
self.debug("Isolated Network successfully deleted in VSD")

110
tools/marvin/marvin/config/test_data.py
View File

@ -1695,5 +1695,115 @@ test_data = {
"ostype": 'CentOS 5.3 (64-bit)',
"mode": 'HTTP_DOWNLOAD'
}
},
# Nuage Vsp supported services
"nuage_vsp_services": {
# Services supported by Nuage Vsp for Isolated networks
"isolated_network_offering": {
"name": 'nuage_marvin',
"displaytext": 'nuage_marvin',
"guestiptype": 'Isolated',
"supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall',
"traffictype": 'GUEST',
"availability": 'Optional',
"serviceProviderList": {
"Dhcp": 'NuageVsp',
"StaticNat": 'NuageVsp',
"SourceNat": 'NuageVsp',
"Firewall": 'NuageVsp',
"Connectivity": 'NuageVsp',
"UserData": 'VirtualRouter'
},
"serviceCapabilityList": {
"SourceNat": {"SupportedSourceNatTypes": "perzone"}
}
},
# Services supported by Nuage Vsp for VPC networks
"vpc_network_offering": {
"name": 'nuage_vpc_marvin',
"displaytext": 'nuage_vpc_marvin',
"guestiptype": 'Isolated',
"supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData',
"traffictype": 'GUEST',
"availability": 'Optional',
"useVpc": 'on',
"ispersistent": 'True',
"serviceProviderList": {
"Dhcp": "NuageVsp",
"StaticNat": "NuageVsp",
"SourceNat": "NuageVsp",
"NetworkACL": "NuageVsp",
"Connectivity": "NuageVsp",
"UserData": "VpcVirtualRouter"
},
"serviceCapabilityList": {
"SourceNat": {"SupportedSourceNatTypes": "perzone"}
}
},
# Nuage Vsp supports only pre-defined and custom VPC offerings
"vpc_offering": {
"name": 'Nuage VSP VPC offering',
"displaytext": 'Nuage VSP VPC offering',
"supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData',
"serviceProviderList": {
"Dhcp": "NuageVsp",
"StaticNat": "NuageVsp",
"SourceNat": "NuageVsp",
"NetworkACL": "NuageVsp",
"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)',
}

55
tools/marvin/marvin/lib/base.py
View File

@ -3957,6 +3957,61 @@ class NetworkServiceProvider:
return(apiclient.listNetworkServiceProviders(cmd))
class Nuage:
"""Manage external nuage VSD device"""
def __init__(self, items):
self.__dict__.update(items)
@classmethod
def add(cls, apiclient, services, physicalnetworkid, username=None, password=None):
"""Add external nuage VSD device to cloudstack"""
cmd = addNuageVspDevice.addNuageVspDeviceCmd()
cmd.physicalnetworkid = physicalnetworkid
if username:
cmd.username = username
else:
cmd.username = services["username"]
if password:
cmd.password = password
else:
cmd.password = services["password"]
cmd.hostname = services["hostname"]
cmd.port = services["port"]
cmd.retrycount = services["retrycount"]
cmd.retryinterval = services["retryinterval"]
cmd.apiversion = services["apiversion"]
return Nuage(apiclient.addNuageVspDevice(cmd).__dict__)
def update(self, apiclient, **kwargs):
"""Deletes a nuage VSD device from CloudStack"""
cmd = updateNuageVspDevice.updateNuageVspDeviceCmd()
cmd.physicalnetworkid = self.physicalnetworkid
[setattr(cmd, k, v) for k, v in kwargs.items()]
return apiclient.updateNuageVspDevice(cmd)
def delete(self, apiclient):
"""Deletes a nuage VSD device from CloudStack"""
cmd = deleteNuageVspDevice.deleteNuageVspDeviceCmd()
cmd.vspdeviceid = self.vspdeviceid
apiclient.deleteNuageVspDevice(cmd)
return
@classmethod
def list(cls, apiclient, **kwargs):
"""List already registered netscaler devices"""
cmd = listNuageVspDevices.listNuageVspDevicesCmd()
[setattr(cmd, k, v) for k, v in kwargs.items()]
return(apiclient.listNuageVspDevices(cmd))
class Router:
"""Manage router life cycle"""