mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
802ddd43ca
Detail: Integration tests use these libraries (base,utils,common) for simplifying the usage of the API. These define the verbs of each entity's usage (create, delete, add etc). For the CLI to present the simplified API we'll leverage the integration libraries. + Fixes to setup-test-data.sh - kvm and xen each use a different version of the built-in Cent OS template, 5.5 and 5.3 namely. At a later point the setup-test-data script needs to be obsoleted. ostypeids in tests should directly be determined from listOsTypes API calls Signed-off-by: Prasanna Santhanam <tsp@apache.org> 1351520707 +0530
1228 lines
50 KiB
Python
1228 lines
50 KiB
Python
# 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 routers
|
|
"""
|
|
#Import Local Modules
|
|
import marvin
|
|
from nose.plugins.attrib import attr
|
|
from marvin.cloudstackTestCase import *
|
|
from marvin.cloudstackAPI import *
|
|
from marvin.integration.lib.utils import *
|
|
from marvin.integration.lib.base import *
|
|
from marvin.integration.lib.common import *
|
|
from marvin.remoteSSHClient import remoteSSHClient
|
|
|
|
#Import System modules
|
|
import time
|
|
|
|
|
|
class Services:
|
|
"""Test router Services
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.services = {
|
|
"service_offering": {
|
|
"name": "Tiny Instance",
|
|
"displaytext": "Tiny Instance",
|
|
"cpunumber": 1,
|
|
"cpuspeed": 100, # in MHz
|
|
"memory": 64, # In MBs
|
|
},
|
|
"virtual_machine":
|
|
{
|
|
"displayname": "Test VM",
|
|
"username": "root",
|
|
"password": "password",
|
|
"ssh_port": 22,
|
|
"hypervisor": 'XenServer',
|
|
# Hypervisor type should be same as
|
|
# hypervisor type of cluster
|
|
"privateport": 22,
|
|
"publicport": 22,
|
|
"protocol": 'TCP',
|
|
},
|
|
"host": {
|
|
"username": "root",
|
|
"password": "password",
|
|
"publicport": 22,
|
|
},
|
|
"account": {
|
|
"email": "test@test.com",
|
|
"firstname": "Test",
|
|
"lastname": "User",
|
|
"username": "testuser",
|
|
"password": "password",
|
|
},
|
|
"natrule":
|
|
{
|
|
"privateport": 22,
|
|
"publicport": 222,
|
|
"protocol": "TCP"
|
|
},
|
|
"lbrule":
|
|
{
|
|
"name": "SSH",
|
|
"alg": "roundrobin",
|
|
# Algorithm used for load balancing
|
|
"privateport": 22,
|
|
"publicport": 2222,
|
|
"protocol": 'TCP',
|
|
},
|
|
"fw_rule": {
|
|
"startport": 1,
|
|
"endport": 6000,
|
|
"cidr": '55.55.0.0/11',
|
|
# Any network (For creating FW rule
|
|
},
|
|
"ostypeid": '01853327-513e-4508-9628-f1f55db1946f',
|
|
# Used for Get_Template : CentOS 5.3 (64 bit)
|
|
"mode": 'advanced', # Networking mode: Advanced, basic
|
|
}
|
|
|
|
|
|
class TestRouterServices(cloudstackTestCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
|
|
cls.api_client = super(TestRouterServices, cls).getClsTestClient().getApiClient()
|
|
cls.services = Services().services
|
|
# Get Zone, Domain and templates
|
|
cls.domain = get_domain(cls.api_client, cls.services)
|
|
cls.zone = get_zone(cls.api_client, cls.services)
|
|
cls.template = get_template(
|
|
cls.api_client,
|
|
cls.zone.id,
|
|
cls.services["ostypeid"]
|
|
)
|
|
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
|
|
|
|
#Create an account, network, VM and IP addresses
|
|
cls.account = Account.create(
|
|
cls.api_client,
|
|
cls.services["account"],
|
|
admin=True,
|
|
domainid=cls.domain.id
|
|
)
|
|
cls.service_offering = ServiceOffering.create(
|
|
cls.api_client,
|
|
cls.services["service_offering"]
|
|
)
|
|
cls.vm_1 = VirtualMachine.create(
|
|
cls.api_client,
|
|
cls.services["virtual_machine"],
|
|
templateid=cls.template.id,
|
|
accountid=cls.account.account.name,
|
|
domainid=cls.account.account.domainid,
|
|
serviceofferingid=cls.service_offering.id
|
|
)
|
|
cls.vm_2 = VirtualMachine.create(
|
|
cls.api_client,
|
|
cls.services["virtual_machine"],
|
|
templateid=cls.template.id,
|
|
accountid=cls.account.account.name,
|
|
domainid=cls.account.account.domainid,
|
|
serviceofferingid=cls.service_offering.id
|
|
)
|
|
cls.cleanup = [
|
|
cls.account,
|
|
cls.service_offering
|
|
]
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
cls.api_client = super(TestRouterServices, cls).getClsTestClient().getApiClient()
|
|
#Clean up, terminate the created templates
|
|
cleanup_resources(cls.api_client, cls.cleanup)
|
|
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def tearDown(self):
|
|
try:
|
|
cleanup_resources(self.apiclient, self._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def setUp(self):
|
|
self.apiclient = self.testClient.getApiClient()
|
|
self._cleanup = []
|
|
return
|
|
|
|
@attr(tags = ["advanced"])
|
|
def test_01_AdvancedZoneRouterServices(self):
|
|
"""Test advanced zone router services
|
|
"""
|
|
# Validate the following:
|
|
# 1. Verify that list of services provided by this network are running
|
|
# a. DNS
|
|
# b. DHCP
|
|
# c. Gateway
|
|
# d. Firewall
|
|
# e. LB
|
|
# f. VPN
|
|
# g. userdata
|
|
# 2. wait for router to start and guest network to be created
|
|
# a. listRouters account=user, domainid=1 (router state=Running)
|
|
# b. listNetworks account=user domainid=1 (network state=Implemented)
|
|
# c. listVirtualMachines account=user domainid=1 (VM state=Running)
|
|
# 3. listNetwork
|
|
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
self.assertNotEqual(
|
|
len(routers),
|
|
0,
|
|
"Check list router response"
|
|
)
|
|
for router in routers:
|
|
self.assertEqual(
|
|
router.state,
|
|
'Running',
|
|
"Check list router response for router state"
|
|
)
|
|
self.debug("Router ID: %s & Router state: %s" % (
|
|
router.id,
|
|
router.state
|
|
))
|
|
# Network state associated with account should be 'Implemented'
|
|
networks = list_networks(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
self.assertEqual(
|
|
isinstance(networks, list),
|
|
True,
|
|
"Check for list networks response return valid data"
|
|
)
|
|
|
|
self.assertNotEqual(
|
|
len(networks),
|
|
0,
|
|
"Check list networks response"
|
|
)
|
|
for network in networks:
|
|
self.assertIn(
|
|
network.state,
|
|
['Implemented', 'Allocated'],
|
|
"Check list network response for network state"
|
|
)
|
|
self.debug("Network ID: %s & Network state: %s" % (
|
|
network.id,
|
|
network.state
|
|
))
|
|
# VM state associated with account should be 'Running'
|
|
virtual_machines = list_virtual_machines(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid
|
|
)
|
|
|
|
self.assertEqual(
|
|
isinstance(virtual_machines, list),
|
|
True,
|
|
"Check for list virtual machines response return valid data"
|
|
)
|
|
self.assertNotEqual(
|
|
len(virtual_machines),
|
|
0,
|
|
"Check list virtual machines response"
|
|
)
|
|
for virtual_machine in virtual_machines:
|
|
self.assertEqual(
|
|
virtual_machine.state,
|
|
'Running',
|
|
"Check list VM response for Running state"
|
|
)
|
|
self.debug("VM ID: %s & VM state: %s" % (
|
|
virtual_machine.id,
|
|
virtual_machine.state
|
|
))
|
|
|
|
# Check status of DNS, DHCP, FIrewall, LB VPN processes
|
|
networks = list_networks(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
self.assertEqual(
|
|
isinstance(networks, list),
|
|
True,
|
|
"Check for list networks response return valid data"
|
|
)
|
|
self.assertNotEqual(
|
|
len(networks),
|
|
0,
|
|
"Check list networks response"
|
|
)
|
|
# Load Balancer, Userdata, VPN, Firewall, Gateway, DNS processes should
|
|
# be running
|
|
for network in networks:
|
|
self.assertEqual(
|
|
'Lb' in str(network.service),
|
|
True,
|
|
"Check Load balancing process in list networks"
|
|
)
|
|
self.assertEqual(
|
|
'UserData' in str(network.service),
|
|
True,
|
|
"Check UserData service in list networks"
|
|
)
|
|
self.assertEqual(
|
|
'Vpn' in str(network.service),
|
|
True,
|
|
"Check Vpn service in list networks"
|
|
)
|
|
self.assertEqual(
|
|
'Firewall' in str(network.service),
|
|
True,
|
|
"Check Firewall service in list networks"
|
|
)
|
|
self.assertEqual(
|
|
'Dns' in str(network.service),
|
|
True,
|
|
"Check Dns service in list networks"
|
|
)
|
|
return
|
|
|
|
@attr(configuration = "network.gc")
|
|
@attr(tags = ["advanced"])
|
|
def test_02_NetworkGarbageCollection(self):
|
|
"""Test network garbage collection
|
|
"""
|
|
# Validate the following
|
|
# 1. wait for router to start and guest network to be created
|
|
# a.listRouters account=user, domainid=1 (router state=Running)
|
|
# b.listNetworks account=user domainid=1 (network state=Implemented)
|
|
# c.listVirtualMachines account=user domainid=1 (VM states=Running)
|
|
# 4. stopVirtualMachines (stop all VMs in this account)
|
|
# 5. wait for VMs to stop-listVirtualMachines account=user, domainid=1
|
|
# (Both VM states = Stopped)
|
|
# 6. wait for network.gc.interval*2 seconds (600s)
|
|
# 7. listRouters account=user, domainid=1
|
|
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
self.assertNotEqual(
|
|
len(routers),
|
|
0,
|
|
"Check list router response"
|
|
)
|
|
# Router associated with account should be in running state
|
|
for router in routers:
|
|
self.assertEqual(
|
|
router.state,
|
|
'Running',
|
|
"Check list router response for router state"
|
|
)
|
|
self.debug("Router ID: %s & Router state: %s" % (
|
|
router.id,
|
|
router.state
|
|
))
|
|
# Network state associated with account should be 'Implemented'
|
|
networks = list_networks(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
self.assertEqual(
|
|
isinstance(networks, list),
|
|
True,
|
|
"Check for list networks response return valid data"
|
|
)
|
|
self.assertNotEqual(
|
|
len(networks),
|
|
0,
|
|
"Check list networks response"
|
|
)
|
|
# Check if network in 'Implemented' state
|
|
for network in networks:
|
|
self.assertIn(
|
|
network.state,
|
|
['Implemented', 'Allocated'],
|
|
"Check list network response for network state"
|
|
)
|
|
self.debug("Network ID: %s & Network state: %s" % (
|
|
network.id,
|
|
network.state
|
|
))
|
|
# VM state associated with account should be 'Running'
|
|
virtual_machines = list_virtual_machines(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
|
|
self.assertEqual(
|
|
isinstance(virtual_machines, list),
|
|
True,
|
|
"Check for list virtual machines response return valid data"
|
|
)
|
|
self.assertNotEqual(
|
|
len(virtual_machines),
|
|
0,
|
|
"Check list virtual machines response"
|
|
)
|
|
for virtual_machine in virtual_machines:
|
|
self.assertEqual(
|
|
virtual_machine.state,
|
|
'Running',
|
|
"Check list VM response for Running state"
|
|
)
|
|
self.debug("VM ID: %s & VM state: %s" % (
|
|
virtual_machine.id,
|
|
virtual_machine.state
|
|
))
|
|
# Stop virtual machine
|
|
cmd = stopVirtualMachine.stopVirtualMachineCmd()
|
|
cmd.id = virtual_machine.id
|
|
self.apiclient.stopVirtualMachine(cmd)
|
|
|
|
gcinterval = list_configurations(
|
|
self.apiclient,
|
|
name='network.gc.interval'
|
|
)
|
|
self.assertEqual(
|
|
isinstance(gcinterval, list),
|
|
True,
|
|
"Check for list intervals response return valid data"
|
|
)
|
|
self.debug("network.gc.interval: %s" % gcinterval[0].value)
|
|
|
|
gcwait = list_configurations(
|
|
self.apiclient,
|
|
name='network.gc.wait'
|
|
)
|
|
self.assertEqual(
|
|
isinstance(gcwait, list),
|
|
True,
|
|
"Check for list intervals response return valid data"
|
|
)
|
|
self.debug("network.gc.wait: %s" % gcwait[0].value)
|
|
|
|
total_wait = int(gcinterval[0].value) + int(gcwait[0].value)
|
|
# Router is stopped after (network.gc.interval *2) time. Wait for
|
|
# (network.gc.interval+network.gc.wait) * 2 for moving router to 'Stopped'
|
|
time.sleep(total_wait * 2)
|
|
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
self.assertNotEqual(
|
|
len(routers),
|
|
0,
|
|
"Check list router response"
|
|
)
|
|
for router in routers:
|
|
self.assertEqual(
|
|
router.state,
|
|
'Stopped',
|
|
"Check list router response for router state"
|
|
)
|
|
self.debug("Router ID: %s & Router state: %s" % (
|
|
router.id,
|
|
router.state
|
|
))
|
|
# Cleanup Vm_2 - Not required for further tests
|
|
self._cleanup.append(self.vm_2)
|
|
return
|
|
|
|
@attr(tags = ["advanced"])
|
|
def test_03_RouterStartOnVmDeploy(self):
|
|
"""Test router start on VM deploy
|
|
"""
|
|
# Validate the following
|
|
# 1. deployVirtualMachine in the account
|
|
# 2. listVirtualMachines account=user, domainid=1
|
|
# 3. when listVirtualMachines reports the userVM to be in state=Running
|
|
# 4. listRouters should report router to have come back to "Running" state
|
|
# 5. All other VMs in the account should remain in "Stopped" state
|
|
|
|
vm = VirtualMachine.create(
|
|
self.apiclient,
|
|
self.services["virtual_machine"],
|
|
templateid=self.template.id,
|
|
accountid=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
serviceofferingid=self.service_offering.id
|
|
)
|
|
self.debug("Deployed a VM with ID: %s" % vm.id)
|
|
|
|
virtual_machines = list_virtual_machines(
|
|
self.apiclient,
|
|
id=vm.id,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
|
|
self.assertEqual(
|
|
isinstance(virtual_machines, list),
|
|
True,
|
|
"Check for list virtual machines response return valid data"
|
|
)
|
|
|
|
self.assertNotEqual(
|
|
len(virtual_machines),
|
|
0,
|
|
"Check list virtual machines response"
|
|
)
|
|
# VM state should be 'Running'
|
|
for virtual_machine in virtual_machines:
|
|
self.assertEqual(
|
|
virtual_machine.state,
|
|
'Running',
|
|
"Check list VM response for Running state"
|
|
)
|
|
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
|
|
self.assertNotEqual(
|
|
len(routers),
|
|
0,
|
|
"Check list router response"
|
|
)
|
|
# Routers associated with account should be 'Running' after deployment
|
|
# of VM
|
|
for router in routers:
|
|
self.assertEqual(
|
|
router.state,
|
|
'Running',
|
|
"Check list router response for router state"
|
|
)
|
|
self.debug("Router ID: %s & Router state: %s" % (
|
|
router.id,
|
|
router.state
|
|
))
|
|
|
|
# All other VMs (VM_1) should be in 'Stopped'
|
|
virtual_machines = list_virtual_machines(
|
|
self.apiclient,
|
|
id=self.vm_1.id,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
|
|
self.assertEqual(
|
|
isinstance(virtual_machines, list),
|
|
True,
|
|
"Check for list VMs response return valid data"
|
|
)
|
|
|
|
self.assertNotEqual(
|
|
len(virtual_machines),
|
|
0,
|
|
"Check list virtual machines response"
|
|
)
|
|
for virtual_machine in virtual_machines:
|
|
self.assertEqual(
|
|
virtual_machine.state,
|
|
'Stopped',
|
|
"Check list VM response for Stopped state"
|
|
)
|
|
self.debug("VM ID: %s & VM state: %s" % (
|
|
virtual_machine.id,
|
|
virtual_machine.state
|
|
))
|
|
return
|
|
|
|
|
|
class TestRouterStopCreatePF(cloudstackTestCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
|
|
cls.api_client = super(TestRouterStopCreatePF, cls).getClsTestClient().getApiClient()
|
|
cls.services = Services().services
|
|
# Get Zone, Domain and templates
|
|
cls.domain = get_domain(cls.api_client, cls.services)
|
|
cls.zone = get_zone(cls.api_client, cls.services)
|
|
template = get_template(
|
|
cls.api_client,
|
|
cls.zone.id,
|
|
cls.services["ostypeid"]
|
|
)
|
|
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
|
|
|
|
#Create an account, network, VM and IP addresses
|
|
cls.account = Account.create(
|
|
cls.api_client,
|
|
cls.services["account"],
|
|
admin=True,
|
|
domainid=cls.domain.id
|
|
)
|
|
cls.service_offering = ServiceOffering.create(
|
|
cls.api_client,
|
|
cls.services["service_offering"]
|
|
)
|
|
cls.vm_1 = VirtualMachine.create(
|
|
cls.api_client,
|
|
cls.services["virtual_machine"],
|
|
templateid=template.id,
|
|
accountid=cls.account.account.name,
|
|
domainid=cls.account.account.domainid,
|
|
serviceofferingid=cls.service_offering.id
|
|
)
|
|
cls.cleanup = [
|
|
cls.account,
|
|
cls.service_offering
|
|
]
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
cls.api_client = super(TestRouterStopCreatePF, cls).getClsTestClient().getApiClient()
|
|
# Clean up, terminate the created resources
|
|
cleanup_resources(cls.api_client, cls.cleanup)
|
|
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def tearDown(self):
|
|
try:
|
|
# Clean up, terminate the created resources
|
|
cleanup_resources(self.apiclient, self._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def setUp(self):
|
|
self.apiclient = self.testClient.getApiClient()
|
|
self._cleanup = []
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns"])
|
|
def test_01_RouterStopCreatePF(self):
|
|
"""Test router stop create port forwarding
|
|
"""
|
|
# validate the following
|
|
# 1. wait for router to start, guest network to be implemented and
|
|
# VM to report Running
|
|
# 2. stopRouter for this account
|
|
# 3. wait for listRouters to report Router as 'Stopped'
|
|
# 4. listPublicIpAddresses account=user, domainid=1 - pick ipaddressid
|
|
# 5. createPortForwardingRule (ipaddressid from step 5.)
|
|
# a. for port 22 (ssh) for user VM deployed in step 1.
|
|
# b. public port 222 , private port 22
|
|
# 6. startRouter stopped for this account
|
|
# 7. wait for listRouters to show router as Running
|
|
|
|
# Get router details associated for that account
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
self.assertNotEqual(
|
|
len(routers),
|
|
0,
|
|
"Check list router response"
|
|
)
|
|
router = routers[0]
|
|
|
|
self.debug("Stopping router ID: %s" % router.id)
|
|
|
|
#Stop the router
|
|
cmd = stopRouter.stopRouterCmd()
|
|
cmd.id = router.id
|
|
self.apiclient.stopRouter(cmd)
|
|
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
router = routers[0]
|
|
|
|
self.assertEqual(
|
|
router.state,
|
|
'Stopped',
|
|
"Check list router response for router state"
|
|
)
|
|
|
|
public_ips = list_publicIP(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
zoneid=self.zone.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(public_ips, list),
|
|
True,
|
|
"Check for list public IPs response return valid data"
|
|
)
|
|
public_ip = public_ips[0]
|
|
|
|
# Open up firewall port for SSH
|
|
fw_rule = FireWallRule.create(
|
|
self.apiclient,
|
|
ipaddressid=public_ip.id,
|
|
protocol=self.services["natrule"]["protocol"],
|
|
cidrlist=['0.0.0.0/0'],
|
|
startport=self.services["natrule"]["publicport"],
|
|
endport=self.services["natrule"]["publicport"]
|
|
)
|
|
|
|
self.debug("Creating NAT rule for VM ID: %s" % self.vm_1.id)
|
|
#Create NAT rule
|
|
nat_rule = NATRule.create(
|
|
self.apiclient,
|
|
self.vm_1,
|
|
self.services["natrule"],
|
|
public_ip.id
|
|
)
|
|
|
|
self.debug("Starting router ID: %s" % router.id)
|
|
#Start the router
|
|
cmd = startRouter.startRouterCmd()
|
|
cmd.id = router.id
|
|
self.apiclient.startRouter(cmd)
|
|
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
zoneid=self.zone.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
router = routers[0]
|
|
|
|
self.assertEqual(
|
|
router.state,
|
|
'Running',
|
|
"Check list router response for router state"
|
|
)
|
|
# NAT Rule should be in Active state after router start
|
|
nat_rules = list_nat_rules(
|
|
self.apiclient,
|
|
id=nat_rule.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(nat_rules, list),
|
|
True,
|
|
"Check for list NAT rules response return valid data"
|
|
)
|
|
self.assertEqual(
|
|
nat_rules[0].state,
|
|
'Active',
|
|
"Check list port forwarding rules"
|
|
)
|
|
try:
|
|
|
|
self.debug("SSH into VM with ID: %s" % nat_rule.ipaddress)
|
|
|
|
self.vm_1.ssh_port = nat_rule.publicport
|
|
self.vm_1.get_ssh_client(nat_rule.ipaddress)
|
|
except Exception as e:
|
|
self.fail(
|
|
"SSH Access failed for %s: %s" % \
|
|
(self.vm_1.ipaddress, e)
|
|
)
|
|
return
|
|
|
|
|
|
class TestRouterStopCreateLB(cloudstackTestCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
|
|
cls.api_client = super(TestRouterStopCreateLB, cls).getClsTestClient().getApiClient()
|
|
cls.services = Services().services
|
|
# Get Zone, Domain and templates
|
|
cls.domain = get_domain(cls.api_client, cls.services)
|
|
cls.zone = get_zone(cls.api_client, cls.services)
|
|
template = get_template(
|
|
cls.api_client,
|
|
cls.zone.id,
|
|
cls.services["ostypeid"]
|
|
)
|
|
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
|
|
|
|
#Create an account, network, VM and IP addresses
|
|
cls.account = Account.create(
|
|
cls.api_client,
|
|
cls.services["account"],
|
|
admin=True,
|
|
domainid=cls.domain.id
|
|
)
|
|
cls.service_offering = ServiceOffering.create(
|
|
cls.api_client,
|
|
cls.services["service_offering"]
|
|
)
|
|
cls.vm_1 = VirtualMachine.create(
|
|
cls.api_client,
|
|
cls.services["virtual_machine"],
|
|
templateid=template.id,
|
|
accountid=cls.account.account.name,
|
|
domainid=cls.account.account.domainid,
|
|
serviceofferingid=cls.service_offering.id
|
|
)
|
|
cls.cleanup = [
|
|
cls.account,
|
|
cls.service_offering
|
|
]
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
cls.api_client = super(TestRouterStopCreateLB, cls).getClsTestClient().getApiClient()
|
|
#Clean up, terminate the created resources
|
|
cleanup_resources(cls.api_client, cls.cleanup)
|
|
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def tearDown(self):
|
|
try:
|
|
cleanup_resources(self.apiclient, self._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def setUp(self):
|
|
self.apiclient = self.testClient.getApiClient()
|
|
self._cleanup = []
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns"])
|
|
def test_01_RouterStopCreateLB(self):
|
|
"""Test router stop create Load balancing
|
|
"""
|
|
# validate the following
|
|
# 1. listLoadBalancerRules (publicipid=ipaddressid of source NAT)
|
|
# 2. rule should be for port 2222 as applied and
|
|
# should be in state=Active
|
|
# 3. ssh access should be allowed to the userVMs over the source NAT IP
|
|
# and port 2222
|
|
|
|
# Get router details associated for that account
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
|
|
self.assertNotEqual(
|
|
len(routers),
|
|
0,
|
|
"Check list router response"
|
|
)
|
|
|
|
router = routers[0]
|
|
|
|
self.debug("Stopping router with ID: %s" % router.id)
|
|
#Stop the router
|
|
cmd = stopRouter.stopRouterCmd()
|
|
cmd.id = router.id
|
|
self.apiclient.stopRouter(cmd)
|
|
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
router = routers[0]
|
|
|
|
self.assertEqual(
|
|
router.state,
|
|
'Stopped',
|
|
"Check list router response for router state"
|
|
)
|
|
|
|
public_ips = list_publicIP(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid
|
|
)
|
|
self.assertEqual(
|
|
isinstance(public_ips, list),
|
|
True,
|
|
"Check for list public IPs response return valid data"
|
|
)
|
|
public_ip = public_ips[0]
|
|
|
|
# Open up firewall port for SSH
|
|
fw_rule = FireWallRule.create(
|
|
self.apiclient,
|
|
ipaddressid=public_ip.id,
|
|
protocol=self.services["lbrule"]["protocol"],
|
|
cidrlist=['0.0.0.0/0'],
|
|
startport=self.services["lbrule"]["publicport"],
|
|
endport=self.services["lbrule"]["publicport"]
|
|
)
|
|
self.debug("Creating LB rule for public IP: %s" % public_ip.id)
|
|
#Create Load Balancer rule and assign VMs to rule
|
|
lb_rule = LoadBalancerRule.create(
|
|
self.apiclient,
|
|
self.services["lbrule"],
|
|
public_ip.id,
|
|
accountid=self.account.account.name
|
|
)
|
|
self.debug("Assigning VM %s to LB rule: %s" % (
|
|
self.vm_1.id,
|
|
lb_rule.id
|
|
))
|
|
lb_rule.assign(self.apiclient, [self.vm_1])
|
|
|
|
#Start the router
|
|
cmd = startRouter.startRouterCmd()
|
|
cmd.id = router.id
|
|
self.apiclient.startRouter(cmd)
|
|
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
router = routers[0]
|
|
|
|
self.assertEqual(
|
|
router.state,
|
|
'Running',
|
|
"Check list router response for router state"
|
|
)
|
|
# After router start, LB RUle should be in Active state
|
|
lb_rules = list_lb_rules(
|
|
self.apiclient,
|
|
id=lb_rule.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(lb_rules, list),
|
|
True,
|
|
"Check for list LB rules response return valid data"
|
|
)
|
|
self.assertEqual(
|
|
lb_rules[0].state,
|
|
'Active',
|
|
"Check list load balancing rules"
|
|
)
|
|
self.assertEqual(
|
|
lb_rules[0].publicport,
|
|
str(self.services["lbrule"]["publicport"]),
|
|
"Check list load balancing rules"
|
|
)
|
|
|
|
try:
|
|
self.debug("SSH into VM with IP: %s" % public_ip.ipaddress)
|
|
self.vm_1.ssh_port = self.services["lbrule"]["publicport"]
|
|
self.vm_1.get_ssh_client(public_ip.ipaddress)
|
|
except Exception as e:
|
|
self.fail(
|
|
"SSH Access failed for %s: %s" % \
|
|
(self.vm_1.ipaddress, e)
|
|
)
|
|
return
|
|
|
|
|
|
class TestRouterStopCreateFW(cloudstackTestCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
|
|
cls.api_client = super(TestRouterStopCreateFW, cls).getClsTestClient().getApiClient()
|
|
cls.services = Services().services
|
|
# Get Zone, Domain and templates
|
|
cls.domain = get_domain(cls.api_client, cls.services)
|
|
cls.zone = get_zone(cls.api_client, cls.services)
|
|
template = get_template(
|
|
cls.api_client,
|
|
cls.zone.id,
|
|
cls.services["ostypeid"]
|
|
)
|
|
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
|
|
|
|
#Create an account, network, VM and IP addresses
|
|
cls.account = Account.create(
|
|
cls.api_client,
|
|
cls.services["account"],
|
|
domainid=cls.domain.id
|
|
)
|
|
cls.service_offering = ServiceOffering.create(
|
|
cls.api_client,
|
|
cls.services["service_offering"]
|
|
)
|
|
cls.vm_1 = VirtualMachine.create(
|
|
cls.api_client,
|
|
cls.services["virtual_machine"],
|
|
templateid=template.id,
|
|
accountid=cls.account.account.name,
|
|
domainid=cls.account.account.domainid,
|
|
serviceofferingid=cls.service_offering.id
|
|
)
|
|
cls.cleanup = [
|
|
cls.account,
|
|
cls.service_offering
|
|
]
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
cls.api_client = super(TestRouterStopCreateFW, cls).getClsTestClient().getApiClient()
|
|
#Clean up, terminate the created templates
|
|
cleanup_resources(cls.api_client, cls.cleanup)
|
|
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def tearDown(self):
|
|
try:
|
|
cleanup_resources(self.apiclient, self._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def setUp(self):
|
|
self.apiclient = self.testClient.getApiClient()
|
|
self._cleanup = []
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns"])
|
|
def test_01_RouterStopCreateFW(self):
|
|
"""Test router stop create Firewall rule
|
|
"""
|
|
# validate the following
|
|
# 1. 1. listFirewallRules (filter by ipaddressid of sourcenat)
|
|
# 2. rule should be for ports 1-600 and in state=Active
|
|
# (optional backend)
|
|
# 3. verify on router using iptables -t nat -nvx if rules are applied
|
|
|
|
# Get the router details associated with account
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
|
|
self.assertNotEqual(
|
|
len(routers),
|
|
0,
|
|
"Check list router response"
|
|
)
|
|
|
|
router = routers[0]
|
|
|
|
self.debug("Stopping the router: %s" % router.id)
|
|
#Stop the router
|
|
cmd = stopRouter.stopRouterCmd()
|
|
cmd.id = router.id
|
|
self.apiclient.stopRouter(cmd)
|
|
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
router = routers[0]
|
|
|
|
self.assertEqual(
|
|
router.state,
|
|
'Stopped',
|
|
"Check list router response for router state"
|
|
)
|
|
|
|
public_ips = list_publicIP(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid
|
|
)
|
|
self.assertEqual(
|
|
isinstance(public_ips, list),
|
|
True,
|
|
"Check for list public IP response return valid data"
|
|
)
|
|
public_ip = public_ips[0]
|
|
|
|
#Create Firewall rule with configurations from settings file
|
|
fw_rule = FireWallRule.create(
|
|
self.apiclient,
|
|
ipaddressid=public_ip.id,
|
|
protocol='TCP',
|
|
cidrlist=[self.services["fw_rule"]["cidr"]],
|
|
startport=self.services["fw_rule"]["startport"],
|
|
endport=self.services["fw_rule"]["endport"]
|
|
)
|
|
self.debug("Created firewall rule: %s" % fw_rule.id)
|
|
|
|
self.debug("Starting the router: %s" % router.id)
|
|
#Start the router
|
|
cmd = startRouter.startRouterCmd()
|
|
cmd.id = router.id
|
|
self.apiclient.startRouter(cmd)
|
|
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
account=self.account.account.name,
|
|
domainid=self.account.account.domainid,
|
|
)
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
|
|
router = routers[0]
|
|
|
|
self.assertEqual(
|
|
router.state,
|
|
'Running',
|
|
"Check list router response for router state"
|
|
)
|
|
# After Router start, FW rule should be in Active state
|
|
fw_rules = list_firewall_rules(
|
|
self.apiclient,
|
|
id=fw_rule.id,
|
|
)
|
|
self.assertEqual(
|
|
isinstance(fw_rules, list),
|
|
True,
|
|
"Check for list FW rules response return valid data"
|
|
)
|
|
|
|
self.assertEqual(
|
|
fw_rules[0].state,
|
|
'Active',
|
|
"Check list load balancing rules"
|
|
)
|
|
self.assertEqual(
|
|
fw_rules[0].startport,
|
|
str(self.services["fw_rule"]["startport"]),
|
|
"Check start port of firewall rule"
|
|
)
|
|
|
|
self.assertEqual(
|
|
fw_rules[0].endport,
|
|
str(self.services["fw_rule"]["endport"]),
|
|
"Check end port of firewall rule"
|
|
)
|
|
hosts = list_hosts(
|
|
self.apiclient,
|
|
id=router.hostid,
|
|
)
|
|
self.assertEqual(
|
|
isinstance(hosts, list),
|
|
True,
|
|
"Check for list hosts response return valid data"
|
|
)
|
|
host = hosts[0]
|
|
# For DNS and DHCP check 'dnsmasq' process status
|
|
result = get_process_status(
|
|
host.ipaddress,
|
|
self.services['host']["publicport"],
|
|
self.services['host']["username"],
|
|
self.services['host']["password"],
|
|
router.linklocalip,
|
|
'iptables -t nat -L'
|
|
)
|
|
self.debug("iptables -t nat -L: %s" % result)
|
|
self.debug("Public IP: %s" % public_ip.ipaddress)
|
|
res = str(result)
|
|
self.assertEqual(
|
|
res.count(str(public_ip.ipaddress)),
|
|
1,
|
|
"Check public IP address"
|
|
)
|
|
return
|