You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cloudstack.apache.org by bh...@apache.org on 2016/03/22 12:44:27 UTC
[30/50] [abbrv] git commit: updated refs/heads/4.9-mvn-upgrade to
7617117
Add nuagevsp userdata testcase (Cloudstack-9095) & Refactor existing testcases
Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/3c8d3d0e
Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/3c8d3d0e
Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/3c8d3d0e
Branch: refs/heads/4.9-mvn-upgrade
Commit: 3c8d3d0ee1288931369650195c8c316508483757
Parents: 359d20e
Author: Sowmya <so...@nokia.com>
Authored: Tue Mar 8 18:13:24 2016 -0800
Committer: Sowmya <so...@nokia.com>
Committed: Tue Mar 8 18:13:24 2016 -0800
----------------------------------------------------------------------
test/integration/component/test_nuage_vsp.py | 334 --------
.../plugins/nuagevsp/nuageTestCase.py | 830 +++++++++++++++++++
.../nuagevsp/test_nuage_password_reset.py | 249 ++++++
.../plugins/nuagevsp/test_nuage_vpc_network.py | 98 +++
.../plugins/nuagevsp/test_nuage_vsp.py | 106 +++
tools/marvin/marvin/config/test_data.py | 110 +++
tools/marvin/marvin/lib/base.py | 55 ++
7 files changed, 1448 insertions(+), 334 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/test/integration/component/test_nuage_vsp.py
----------------------------------------------------------------------
diff --git a/test/integration/component/test_nuage_vsp.py b/test/integration/component/test_nuage_vsp.py
deleted file mode 100644
index e7bd10e..0000000
--- a/test/integration/component/test_nuage_vsp.py
+++ /dev/null
@@ -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
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/test/integration/plugins/nuagevsp/nuageTestCase.py
----------------------------------------------------------------------
diff --git a/test/integration/plugins/nuagevsp/nuageTestCase.py b/test/integration/plugins/nuagevsp/nuageTestCase.py
new file mode 100644
index 0000000..123f2bc
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/nuageTestCase.py
@@ -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"
+ )
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/test/integration/plugins/nuagevsp/test_nuage_password_reset.py
----------------------------------------------------------------------
diff --git a/test/integration/plugins/nuagevsp/test_nuage_password_reset.py b/test/integration/plugins/nuagevsp/test_nuage_password_reset.py
new file mode 100644
index 0000000..3e600c2
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/test_nuage_password_reset.py
@@ -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)
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/test/integration/plugins/nuagevsp/test_nuage_vpc_network.py
----------------------------------------------------------------------
diff --git a/test/integration/plugins/nuagevsp/test_nuage_vpc_network.py b/test/integration/plugins/nuagevsp/test_nuage_vpc_network.py
new file mode 100644
index 0000000..3fc9c32
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/test_nuage_vpc_network.py
@@ -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)
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/test/integration/plugins/nuagevsp/test_nuage_vsp.py
----------------------------------------------------------------------
diff --git a/test/integration/plugins/nuagevsp/test_nuage_vsp.py b/test/integration/plugins/nuagevsp/test_nuage_vsp.py
new file mode 100644
index 0000000..a6ec7e1
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/test_nuage_vsp.py
@@ -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")
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/tools/marvin/marvin/config/test_data.py
----------------------------------------------------------------------
diff --git a/tools/marvin/marvin/config/test_data.py b/tools/marvin/marvin/config/test_data.py
index 3d4745d..352f8a2 100644
--- a/tools/marvin/marvin/config/test_data.py
+++ b/tools/marvin/marvin/config/test_data.py
@@ -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)',
+
}
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/tools/marvin/marvin/lib/base.py
----------------------------------------------------------------------
diff --git a/tools/marvin/marvin/lib/base.py b/tools/marvin/marvin/lib/base.py
index 0be8909..e2f4a2c 100755
--- a/tools/marvin/marvin/lib/base.py
+++ b/tools/marvin/marvin/lib/base.py
@@ -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"""