def stop_master_router(self, vpc):
self.logger.debug("Stopping Master Router of VPC '%s'...", vpc.name)
routers = list_routers(self.api_client, domainid=self.domain.id, account=self.account.name, vpcid=vpc.id)
for router in routers:
if router.redundantstate == 'MASTER':
cmd = stopRouter.stopRouterCmd()
cmd.id = router.id
cmd.forced = 'true'
self.api_client.stopRouter(cmd)
break
routers = list_routers(self.api_client, domainid=self.domain.id, account=self.account.name, vpcid=vpc.id)
for router in routers:
if router.state == 'Running':
hosts = list_hosts(self.api_client, zoneid=router.zoneid, type='Routing', state='Up', id=router.hostid)
self.assertTrue(isinstance(hosts, list))
host = next(iter(hosts or []), None)
try:
host.user, host.passwd = get_host_credentials(self.config, host.ipaddress)
get_process_status(host.ipaddress, 22, host.user, host.passwd, router.linklocalip, "sh /opt/cloud/bin/checkrouter.sh ")
except KeyError as e:
raise Exception("Exception: %s" % e)
self.logger.debug("Master Router of VPC '%s' stopped", vpc.name)
def test_10_reboot_router_forced(self):
"""Test force reboot router
"""
list_router_response = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(list_router_response, list), True,
"Check list response returns a valid list")
router = list_router_response[0]
public_ip = router.publicip
self.debug("Force rebooting the router with ID: %s" % router.id)
# Reboot the router
cmd = rebootRouter.rebootRouterCmd()
cmd.id = router.id
cmd.forced = True
self.apiclient.rebootRouter(cmd)
# List routers to check state of router
retries_cnt = 10
while retries_cnt >= 0:
router_response = list_routers(self.apiclient, id=router.id)
if self.verifyRouterResponse(router_response, public_ip):
self.debug("Router is running successfully after force reboot")
return
time.sleep(10)
retries_cnt = retries_cnt - 1
self.fail("Router response after force reboot is either invalid\
or router in stopped state")
return
def perform_password_service_tests(self, vpc_off):
if vpc_off is None:
self.logger.debug("No need to create a VPC, creating isolated network")
network_1 = self.createIsolatedNetwork()
vpc_1 = None
else:
self.logger.debug("Creating VPC with offering ID %s" % vpc_off.id)
vpc_1 = self.createVPC(vpc_off, cidr='10.0.0.0/16')
self.logger.debug("Creating network inside VPC")
net_off = get_default_network_offering(self.apiclient)
network_1 = self.createNetwork(vpc_1, net_off, gateway='10.0.0.1')
acl1 = self.createACL(vpc_1)
self.createACLItem(acl1.id, cidr="0.0.0.0/0")
self.replaceNetworkAcl(acl1.id, network_1)
routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid)
for router in routers:
self._perform_password_service_test(router, network_1)
# Do the same after restart with cleanup
if vpc_off is None:
self.restart_network_with_cleanup(network_1, True)
else:
self.restart_vpc_with_cleanup(vpc_1, True)
self.logger.debug("Getting the router info again after the cleanup (router names / ip addresses changed)")
routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid)
self.assertEqual(isinstance(routers, list), True,
"Check for list routers response return valid data")
self.logger.debug("Check whether routers are happy")
for router in routers:
self._perform_password_service_test(router, network_1)
def reboot_Router(self):
vm_network_id = self.virtual_machine.nic[0].networkid
list_routers_response = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
networkid=vm_network_id)
self.assertEqual(isinstance(list_routers_response, list),
True,
"Check for list routers response return valid data")
router = list_routers_response[0]
#Reboot the router
cmd = rebootRouter.rebootRouterCmd()
cmd.id = router.id
self.apiclient.rebootRouter(cmd)
#List routers to check state of router
router_response = list_routers(self.apiclient,
id=router.id)
self.assertEqual(isinstance(router_response, list),
True,
"Check list response returns a valid list")
#List router should have router in running state and same public IP
self.assertEqual(router_response[0].state,
'Running',
"Check list router response for router state")
def perform_dnsmasq_service_dns_tests(self, vpc_off):
self.logger.debug("Creating VPC with offering ID %s" % vpc_off.id)
vpc_1 = self.createVPC(vpc_off, cidr='10.0.0.0/16')
self.logger.debug("Creating network inside VPC")
net_off = get_default_network_offering(self.apiclient)
network_1 = self.createNetwork(vpc_1, net_off, gateway='10.0.0.1')
acl1 = self.createACL(vpc_1)
self.createACLItem(acl1.id, cidr="0.0.0.0/0")
self.replaceNetworkAcl(acl1.id, network_1)
routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid)
for router in routers:
if router.redundantstate == 'MASTER' or len(routers) == 1:
self._perform_dnsmasq_service_dns_test(router, network_1)
# Do the same after restart with cleanup
self.restart_vpc_with_cleanup(vpc_1, True)
self.logger.debug("Getting the router info again after the cleanup (router names / ip addresses changed)")
routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid)
self.assertEqual(isinstance(routers, list), True,
"Check for list routers response return valid data")
self.logger.debug("Check whether routers are happy")
for router in routers:
if router.redundantstate == 'MASTER' or len(routers) == 1:
self._perform_dnsmasq_service_dns_test(router, network_1)
def stop_master_router(self, vpc):
self.logger.debug("Stopping Master Router of VPC '%s'...", vpc.name)
routers = list_routers(self.api_client, domainid=self.domain.id, account=self.account.name, vpcid=vpc.id)
for router in routers:
if router.redundantstate == 'MASTER':
cmd = stopRouter.stopRouterCmd()
cmd.id = router.id
cmd.forced = 'true'
self.api_client.stopRouter(cmd)
break
routers = list_routers(self.api_client, domainid=self.domain.id, account=self.account.name, vpcid=vpc.id)
for router in routers:
if router.state == 'Running':
hosts = list_hosts(self.api_client, zoneid=router.zoneid, type='Routing', state='Up', id=router.hostid)
self.assertTrue(isinstance(hosts, list))
host = next(iter(hosts or []), None)
try:
host.user, host.passwd = get_host_credentials(self.config, host.name)
get_process_status(host.ipaddress, 22, host.user, host.passwd, router.linklocalip, "sh /opt/cosmic/router/scripts/checkrouter.sh ")
except KeyError as e:
raise Exception("Exception: %s" % e)
self.logger.debug("Master Router of VPC '%s' stopped", vpc.name)
def perform_password_service_tests(self, vpc_off):
self.enable_template_password(
template_id=self.template.id,
passwordenabled=True)
self.logger.debug("Creating VPC with offering ID %s" % vpc_off.id)
vpc_1 = self.createVPC(vpc_off, cidr='10.0.0.0/16')
self.logger.debug("Creating network inside VPC")
net_off = get_default_network_offering(self.apiclient)
network_1 = self.createNetwork(vpc_1, net_off, gateway='10.0.0.1')
acl1 = self.createACL(vpc_1)
self.createACLItem(acl1.id, cidr="0.0.0.0/0")
self.replaceNetworkAcl(acl1.id, network_1)
routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid)
for router in routers:
if router.redundantstate == 'MASTER' or len(routers) == 1:
self._perform_password_service_test(router, network_1)
# Do the same after restart with cleanup
self.restart_vpc_with_cleanup(vpc_1, True)
self.logger.debug("Getting the router info again after the cleanup (router names / ip addresses changed)")
routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid)
self.assertEqual(isinstance(routers, list), True,
"Check for list routers response return valid data")
self.logger.debug("Check whether routers are happy")
for router in routers:
if router.redundantstate == 'MASTER' or len(routers) == 1:
self._perform_password_service_test(router, network_1)
self.enable_template_password(
template_id=self.template.id,
passwordenabled=False)
def test_08_start_router(self):
"""Test start router
"""
# Validate the following
# 1. listRouter should report the router for the account as stopped
list_router_response = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(list_router_response, list), True,
"Check list response returns a valid list")
router = list_router_response[0]
self.debug("Starting the router with ID: %s" % router.id)
# Start the router
cmd = startRouter.startRouterCmd()
cmd.id = router.id
self.apiclient.startRouter(cmd)
# List routers to check state of router
router_response = list_routers(self.apiclient, id=router.id)
self.assertEqual(isinstance(router_response, list), True,
"Check list response returns a valid list")
# List router should have router in running state
self.assertEqual(router_response[0].state, 'Running',
"Check list router response for router state")
return
def test_01_router_internal_basic(self):
"""Test router internal basic zone
"""
# Validate the following
# 1. Router only does dhcp
# 2. Verify that ports 67 (DHCP) and 53 (DNS) are open on UDP
# by checking status of dnsmasq process
# Find router associated with user account
if self.zone.networktype == "Basic":
list_router_response = list_routers(self.apiclient, listall="true")
else:
list_router_response = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(list_router_response, list), True,
"Check list response returns a valid list")
router = list_router_response[0]
hosts = list_hosts(self.apiclient,
zoneid=router.zoneid,
type='Routing',
state='Up',
id=router.hostid)
self.assertEqual(isinstance(hosts, list), True,
"Check list host returns a valid list")
host = hosts[0]
self.debug("Router ID: %s, state: %s" % (router.id, router.state))
self.assertEqual(router.state, 'Running',
"Check list router response for router state")
if self.hypervisor.lower() in ('vmware', 'hyperv'):
result = get_process_status(self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
router.linklocalip,
"systemctl is-active dnsmasq",
hypervisor=self.hypervisor)
else:
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = get_process_status(host.ipaddress, 22, host.user,
host.passwd, router.linklocalip,
"systemctl is-active dnsmasq")
except KeyError:
self.skipTest("Marvin configuration has no host credentials to\
check router services")
res = str(result)
self.debug("Dnsmasq process status: %s" % res)
self.assertEqual(res.count("active"), 1,
"Check dnsmasq service is running or not")
return
def test_06_reboot_VR_verify_ip_alias(self):
"""Reboot VR and verify ip alias
1.Deploy guest vm in new cidr
2.Verify ip alias creation
3.Reboot VR
4.Verify ip alias on VR
"""
list_router_response = list_routers(self.apiclient,
zoneid=self.zone.id,
listall=True)
self.assertEqual(isinstance(list_router_response, list), True,
"Check list response returns a valid list")
router = list_router_response[0]
hosts = list_hosts(self.apiclient,
zoneid=router.zoneid,
type='Routing',
state='Up',
id=router.hostid)
self.assertEqual(isinstance(hosts, list), True,
"Check list host returns a valid list")
host = hosts[0]
self.debug("Router ID: %s, state: %s" % (router.id, router.state))
self.assertEqual(router.state, 'Running',
"Check list router response for router state")
port = self.testdata['configurableData']['host']["publicport"]
username = self.testdata['configurableData']['host']["username"]
password = self.testdata['configurableData']['host']["password"]
# SSH to host so that host key is saved in first
# attempt
SshClient(host.ipaddress, port, username, password)
proc = "ip addr show eth0"
result = get_process_status(host.ipaddress, port, username, password,
router.linklocalip, proc)
res = str(result)
self.debug("ip alias configuration on VR: %s" % res)
self.assertNotEqual(
res.find(self.alias_ip) - 1, "ip alias is not created on VR eth0")
resp = Router.reboot(self.apiclient, router.id)
self.debug("Reboot router api response: %s" % resp)
list_router_response = list_routers(self.apiclient,
zoneid=self.zone.id,
listall=True)
self.assertEqual(isinstance(list_router_response, list), True,
"Check list response returns a valid list")
router = list_router_response[0]
self.assertEqual(router.state, 'Running',
"Router is not in running state after reboot")
result = get_process_status(host.ipaddress, port, username, password,
router.linklocalip, proc)
res = str(result)
self.assertNotEqual(res.find(self.alias_ip), -1,
"IP alias not present on VR after VR reboot")
return
def test_03_restart_network_cleanup(self):
"""Test restart network
"""
# Validate the following
# 1. When cleanup = true, router is destroyed and a new one created
# 2. New router should have the same public IP
# Find router associated with user account
list_router_response = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(list_router_response, list), True,
"Check list response returns a valid list")
router = list_router_response[0]
# Store old values before restart
old_publicip = router.publicip
timeout = 10
# Network should be in Implemented or Setup stage before restart
while True:
networks = list_networks(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(networks, list), True,
"Check list response returns a valid list")
network = networks[0]
if network.state in ["Implemented", "Setup"]:
break
elif timeout == 0:
break
else:
time.sleep(self.services["sleep"])
timeout = timeout - 1
self.debug("Restarting network with ID: %s, Network state: %s" %
(network.id, network.state))
cmd = restartNetwork.restartNetworkCmd()
cmd.id = network.id
cmd.cleanup = True
self.apiclient.restartNetwork(cmd)
# Get router details after restart
list_router_response = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(list_router_response, list), True,
"Check list response returns a valid list")
router = list_router_response[0]
self.assertEqual(
router.publicip, old_publicip,
"Public IP of the router should remain same after network restart")
return
def test_01_stop_start_router_after_creating_vpc(self):
""" Test to stop and start router after creation of VPC
"""
# Validate following:
# 1. Create a VPC with cidr - 10.1.1.1/16
# 2. Stop the VPC Virtual Router which is created as a result of VPC creation.
# 3. Start the Stopped VPC Virtual Router
self.validate_vpc_offering(self.vpc_off)
self.validate_vpc_network(self.vpc)
# Stop the VPC Router
routers = Router.list(self.api_client,
account=self.account.name,
domainid=self.account.domainid,
listall=True)
self.assertEqual(isinstance(routers, list), True,
"List Routers should return a valid list")
router = routers[0]
self.debug("Stopping the router with ID: %s" % router.id)
# Stop the router
cmd = stopRouter.stopRouterCmd()
cmd.id = router.id
self.api_client.stopRouter(cmd)
# List routers to check state of router
router_response = list_routers(self.api_client, id=router.id)
self.assertEqual(isinstance(router_response, list), True,
"Check list response returns a valid list")
# List router should have router in stopped state
self.assertEqual(router_response[0].state, 'Stopped',
"Check list router response for router state")
self.debug("Stopped the router with ID: %s" % router.id)
# Start The Router
self.debug("Starting the router with ID: %s" % router.id)
cmd = startRouter.startRouterCmd()
cmd.id = router.id
self.api_client.startRouter(cmd)
# List routers to check state of router
router_response = list_routers(self.api_client, id=router.id)
self.assertEqual(isinstance(router_response, list), True,
"Check list response returns a valid list")
# List router should have router in running state
self.assertEqual(router_response[0].state, 'Running',
"Check list router response for router state")
self.debug("Started the router with ID: %s" % router.id)
return
def test_01_restart_network_cleanup(self):
"""TS_BUG_008-Test restart network
"""
# Validate the following
# 1. When cleanup = true, router is destroyed and a new one created
# 2. New router will have new publicIp and linkLocalIp and
# all it's services should resume
# Find router associated with user account
list_router_response = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(list_router_response, list), True,
"Check list response returns a valid list")
router = list_router_response[0]
#Store old values before restart
old_linklocalip = router.linklocalip
timeout = 10
# Network should be in Implemented or Setup stage before restart
while True:
networks = Network.list(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
network = networks[0]
if network.state in ["Implemented", "Setup"]:
break
elif timeout == 0:
break
else:
time.sleep(60)
timeout = timeout - 1
self.debug("Restarting network: %s" % network.id)
cmd = restartNetwork.restartNetworkCmd()
cmd.id = network.id
cmd.cleanup = True
self.apiclient.restartNetwork(cmd)
# Get router details after restart
list_router_response = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(list_router_response, list), True,
"Check list response returns a valid list")
router = list_router_response[0]
self.assertNotEqual(router.linklocalip, old_linklocalip,
"Check link-local IP after restart")
return
def test_02_ping_in_vr_failure(self):
'''
Test Ping command execution in VR
'''
# Validate the following:
# 1. Ping command is executed remotely on VR
# 2. Validate Ping command execution with a non-existent/pingable IP address
if self.hypervisor.lower() == 'simulator':
raise self.skipTest("Skipping negative test case for Simulator hypervisor")
list_router_response = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_router_response, list),
True,
"Check list response returns a valid list"
)
router = list_router_response[0]
self.debug('Starting the router with ID: %s' % router.id)
cmd = runDiagnostics.runDiagnosticsCmd()
cmd.targetid = router.id
cmd.ipaddress = '192.0.2.2'
cmd.type = 'ping'
cmd_response = self.apiclient.runDiagnostics(cmd)
self.assertNotEqual(
'0',
cmd_response.exitcode,
'Check diagnostics command returns a non-zero exit code')
def routers_in_right_state(self):
self.logger.debug("Check whether routers are happy")
max_tries = 30
test_tries = 0
master_found = 0
backup_found = 0
while test_tries < max_tries:
routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid)
self.assertEqual(isinstance(routers, list), True,
"Check for list routers response return valid data")
for router in routers:
if not router.isredundantrouter:
self.logger.debug("Router %s has is_redundant_router %s so continuing" % (router.linklocalip, router.isredundantrouter))
return True
router_state = self.get_router_state(router)
if router_state == "BACKUP":
backup_found += 1
self.logger.debug("Router %s currently is in state BACKUP" % router.linklocalip)
if router_state == "MASTER":
master_found += 1
self.logger.debug("Router %s currently is in state MASTER" % router.linklocalip)
if master_found > 0 and backup_found > 0:
self.logger.debug("Found at least one router in MASTER and one in BACKUP state so continuing")
break
test_tries += 1
self.logger.debug("Testing router states round %s/%s" % (test_tries, max_tries))
time.sleep(2)
if master_found == 1 and backup_found == 1:
return True
return False
def test_02_reboot_router_after_creating_vpc(self):
""" Test to reboot the router after creating a VPC
"""
# Validate the following
# 1. Create a VPC with cidr - 10.1.1.1/16
# 2. Reboot the VPC Virtual Router which is created as a result of VPC creation.
# Stop the VPC Router
self.validate_vpc_offering(self.vpc_off)
self.validate_vpc_network(self.vpc)
routers = Router.list(self.api_client,
account=self.account.name,
domainid=self.account.domainid,
listall=True)
self.assertEqual(isinstance(routers, list), True,
"List Routers should return a valid list")
router = routers[0]
self.debug("Rebooting the router ...")
# Reboot the router
cmd = rebootRouter.rebootRouterCmd()
cmd.id = router.id
self.api_client.rebootRouter(cmd)
# List routers to check state of router
router_response = list_routers(self.api_client, id=router.id)
self.assertEqual(isinstance(router_response, list), True,
"Check list response returns a valid list")
# List router should have router in running state and same public IP
self.assertEqual(router_response[0].state, 'Running',
"Check list router response for router state")
return
def test_10_traceroute_in_vr(self):
'''
Test Arping command execution in VR
'''
# Validate the following:
# 1. Arping command is executed remotely on VR
list_router_response = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_router_response, list),
True,
"Check list response returns a valid list"
)
router = list_router_response[0]
self.debug('Starting the router with ID: %s' % router.id)
cmd = runDiagnostics.runDiagnosticsCmd()
cmd.targetid = router.id
cmd.ipaddress = '8.8.4.4'
cmd.type = 'traceroute'
cmd.params = "-m 10"
cmd_response = self.apiclient.runDiagnostics(cmd)
self.assertEqual(
'0',
cmd_response.exitcode,
'Failed to run remote Arping in VR')
def test_02_ping_in_vr_failure(self):
'''
Test Ping command execution in VR
'''
# Validate the following:
# 1. Ping command is executed remotely on VR
# 2. Validate Ping command execution with a non-existent/pingable IP address
if self.hypervisor.lower() == 'simulator':
raise self.skipTest("Skipping negative test case for Simulator hypervisor")
list_router_response = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_router_response, list),
True,
"Check list response returns a valid list"
)
router = list_router_response[0]
self.debug('Starting the router with ID: %s' % router.id)
cmd = runDiagnostics.runDiagnosticsCmd()
cmd.targetid = router.id
cmd.ipaddress = '192.0.2.2'
cmd.type = 'ping'
cmd_response = self.apiclient.runDiagnostics(cmd)
self.assertNotEqual(
'0',
cmd_response.exitcode,
'Check diagnostics command returns a non-zero exit code')
def test_05_router_basic(self):
"""Test router basic setup
"""
# Validate the following:
# 1. verify that listRouters returned a 'Running' router
# 2. router will have dns same as that seen in listZones
# 3. router will have a guestIP and a linkLocalIp"
list_router_response = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(list_router_response, list), True,
"Check list response returns a valid list")
self.assertNotEqual(len(list_router_response), 0,
"Check list router response")
for router in list_router_response:
self.assertEqual(router.state, 'Running',
"Check list router response for router state")
zones = list_zones(self.apiclient, id=router.zoneid)
self.assertEqual(isinstance(zones, list), True,
"Check list response returns a valid list")
zone = zones[0]
self.assertEqual(router.dns1, zone.dns1,
"Compare DNS1 of router and zone")
self.assertEqual(router.dns2, zone.dns2,
"Compare DNS2 of router and zone")
self.assertEqual(hasattr(router, 'guestipaddress'), True,
"Check whether router has guest IP field")
self.assertEqual(hasattr(router, 'linklocalip'), True,
"Check whether router has link local IP field")
return
def test_01_ping_in_vr_success(self):
'''
Test Ping command execution in VR
'''
# Validate the following:
# 1. Ping command is executed remotely on VR
list_router_response = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_router_response, list),
True,
"Check list response returns a valid list"
)
router = list_router_response[0]
self.debug('Starting the router with ID: %s' % router.id)
cmd = runDiagnostics.runDiagnosticsCmd()
cmd.targetid = router.id
cmd.ipaddress = '8.8.8.8'
cmd.type = 'ping'
cmd_response = self.apiclient.runDiagnostics(cmd)
self.assertEqual(
'0',
cmd_response.exitcode,
'Failed to run remote Ping in VR')
def test_14_retrieve_vr_one_file(self):
list_router_response = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_router_response, list),
True,
"Check list response returns a valid list"
)
router = list_router_response[0]
self.debug('Setting up VR with ID %s' % router.id)
cmd = getDiagnosticsData.getDiagnosticsDataCmd()
cmd.targetid = router.id
cmd.type = "/var/log/cloud.log"
response = self.apiclient.getDiagnosticsData(cmd)
is_valid_url = self.check_url(response.url)
self.assertEqual(
True,
is_valid_url,
msg="Failed to create valid download url response"
)
def routers_in_right_state(self):
self.logger.debug("Check whether routers are happy")
max_tries = 30
test_tries = 0
master_found = 0
backup_found = 0
while test_tries < max_tries:
routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid)
self.assertEqual(isinstance(routers, list), True,
"Check for list routers response return valid data")
for router in routers:
if not router.isredundantrouter:
self.logger.debug("Router %s has is_redundant_router %s so continuing" % (router.linklocalip, router.isredundantrouter))
return True
router_state = self.get_router_state(router)
if router_state == "BACKUP":
backup_found += 1
self.logger.debug("Router %s currently is in state BACKUP" % router.linklocalip)
if router_state == "MASTER":
master_found += 1
self.logger.debug("Router %s currently is in state MASTER" % router.linklocalip)
if master_found > 0 and backup_found > 0:
self.logger.debug("Found at least one router in MASTER and one in BACKUP state so continuing")
break
test_tries += 1
self.logger.debug("Testing router states round %s/%s" % (test_tries, max_tries))
time.sleep(2)
if master_found == 1 and backup_found == 1:
return True
return False
def test_router_common(self):
"""Performs common router tests and returns router public_ips"""
routers = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(routers, list), True,
"Check for list routers response return valid data")
self.assertTrue(len(routers) >= 1, "Check list router response")
router = routers[0]
self.assertEqual(router.state, 'Running',
"Check list router response for router state")
public_ips = list_publicIP(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id)
self.assertEqual(
isinstance(public_ips, list), True,
"Check for list public IPs response return valid data")
self.assertTrue(
len(public_ips) >= 1, "Check public IP list has at least one IP")
return public_ips
def get_routers_for_network(self, network):
return list_routers(
self.api_client,
account='admin',
domainid=self.domain.id,
networkid=network.id
)
def get_routers(self, network_id):
routers = list_routers(self.apiclient,
networkid=network_id,
listall=True)
self.assertEqual(isinstance(routers, list), True,
"Check for list routers response return valid data")
self.assertNotEqual(len(routers), 0, "Check list router response")
return routers
def query_routers(self):
self.routers = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
)
self.assertEqual(
isinstance(self.routers, list), True,
"Check for list routers response return valid data")
def query_routers(self):
self.routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
)
self.assertEqual(isinstance(self.routers, list), True,
"Check for list routers response return valid data")
def migrate_router(self, router):
""" Migrate the router """
self.debug("Checking if the host is available for migration?")
hosts = Host.list(self.api_client, zoneid=self.zone.id, type='Routing')
self.assertEqual(
isinstance(hosts, list),
True,
"List hosts should return a valid list"
)
if len(hosts) < 2:
self.skipTest(
"No host available for migration. Test requires atleast 2 hosts")
# Remove the host of current VM from the hosts list
hosts[:] = [host for host in hosts if host.id != router.hostid]
host = hosts[0]
self.debug("Validating if the network rules work properly or not?")
self.debug("Migrating VM-ID: %s from %s to Host: %s" % (
router.id,
router.hostid,
host.id
))
try:
# Migrate the router
cmd = migrateSystemVm.migrateSystemVmCmd()
cmd.isAsync = "false"
cmd.hostid = host.id
cmd.virtualmachineid = router.id
self.api_client.migrateSystemVm(cmd)
except Exception as e:
self.fail("Failed to migrate instance, %s" % e)
self.debug("Waiting for Router mgiration ....")
time.sleep(240)
# List routers to check state of router
router_response = list_routers(
self.api_client,
id=router.id
)
self.assertEqual(
isinstance(router_response, list),
True,
"Check list response returns a valid list"
)
router.hostid = router_response[0].hostid
self.assertEqual(
router.hostid, host.id, "Migration to host %s failed. The router host is"
"still %s" %
(host.id, router.hostid))
return
def test_09_reboot_router(self):
"""Test reboot router
"""
# Validate the following
# 1. listRouter should report the router for the account as stopped
list_router_response = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_router_response, list),
True,
"Check list response returns a valid list"
)
router = list_router_response[0]
public_ip = router.publicip
self.debug("Rebooting the router with ID: %s" % router.id)
# Reboot the router
cmd = rebootRouter.rebootRouterCmd()
cmd.id = router.id
self.apiclient.rebootRouter(cmd)
# List routers to check state of router
retries_cnt = 6
while retries_cnt >= 0:
router_response = list_routers(
self.apiclient,
id=router.id
)
if self.verifyRouterResponse(router_response, public_ip):
self.debug("Router is running successfully after reboot")
return
time.sleep(10)
retries_cnt = retries_cnt - 1
self.fail(
"Router response after reboot is either is invalid\
or in stopped state")
return
def test_08_start_router(self):
"""Test start router
"""
# Validate the following
# 1. listRouter should report the router for the account as stopped
list_router_response = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_router_response, list),
True,
"Check list response returns a valid list"
)
router = list_router_response[0]
self.debug("Starting the router with ID: %s" % router.id)
# Start the router
cmd = startRouter.startRouterCmd()
cmd.id = router.id
self.apiclient.startRouter(cmd)
# List routers to check state of router
router_response = list_routers(
self.apiclient,
id=router.id
)
self.assertEqual(
isinstance(router_response, list),
True,
"Check list response returns a valid list"
)
# List router should have router in running state
self.assertEqual(
router_response[0].state,
'Running',
"Check list router response for router state"
)
return
def test_isolate_network_FW_PF_default_routes(self):
"""Stop existing router, add a PF rule and check we can access the VM """
self.logger.debug("Starting test_isolate_network_FW_PF_default_routes...")
routers = list_routers(self.apiclient, account=self.account.name, domainid=self.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.assertEqual(router.state, "Running", "Check list router response for router state")
public_ips = list_publicIP(
self.apiclient, account=self.account.name, domainid=self.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]
self.logger.debug("Creating Firewall rule for VM ID: %s" % self.vm_1.id)
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.logger.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)
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")
result = "failed"
try:
ssh_command = "ping -c 3 8.8.8.8"
self.logger.debug("SSH into VM with ID: %s" % nat_rule.ipaddress)
ssh = self.vm_1.get_ssh_client(
ipaddress=nat_rule.ipaddress, port=self.services["natrule"]["publicport"], retries=5
)
result = str(ssh.execute(ssh_command))
self.logger.debug("SSH result: %s; COUNT is ==> %s" % (result, result.count("3 packets received")))
except:
self.fail("Failed to SSH into VM - %s" % (public_ip.ipaddress.ipaddress))
self.assertEqual(result.count("3 packets received"), 1, "Ping to outside world from VM should be successful")
return
def get_vpcrouter(self):
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.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]
return router
def reboot_Router(self):
vm_network_id = self.virtual_machine.nic[0].networkid
list_routers_response = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
networkid=vm_network_id)
self.assertEqual(isinstance(list_routers_response, list), True,
"Check for list routers response return valid data")
router = list_routers_response[0]
#Reboot the router
cmd = rebootRouter.rebootRouterCmd()
cmd.id = router.id
self.apiclient.rebootRouter(cmd)
#List routers to check state of router
router_response = list_routers(self.apiclient, id=router.id)
self.assertEqual(isinstance(router_response, list), True,
"Check list response returns a valid list")
#List router should have router in running state and same public IP
self.assertEqual(router_response[0].state, 'Running',
"Check list router response for router state")
def test_delete_account(self):
"""Test for delete account"""
# Validate the Following
# 1. after account.cleanup.interval (global setting)
# time all the PF/LB rules should be deleted
# 2. verify that list(LoadBalancer/PortForwarding)Rules
# API does not return any rules for the account
# 3. The domR should have been expunged for this account
self.account.delete(self.apiclient)
interval = list_configurations(self.apiclient,
name='account.cleanup.interval')
self.assertEqual(isinstance(interval, list), True,
"Check if account.cleanup.interval config present")
# Sleep to ensure that all resources are deleted
time.sleep(int(interval[0].value))
# ListLoadBalancerRules should not list
# associated rules with deleted account
# Unable to find account testuser1 in domain 1 : Exception
try:
list_lb_rules(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
except CloudstackAPIException:
self.debug("Port Forwarding Rule is deleted")
# ListPortForwardingRules should not
# list associated rules with deleted account
try:
list_nat_rules(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
except CloudstackAPIException:
self.debug("NATRule is deleted")
# Retrieve router for the user account
try:
routers = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(routers, None,
"Check routers are properly deleted.")
except CloudstackAPIException:
self.debug("Router is deleted")
except Exception as e:
raise Exception(
"Encountered %s raised while fetching routers for account: %s"
% (e, self.account.name))
return
def query_routers(self, count=2, showall=False):
self.routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
)
if not showall:
self.routers = [r for r in self.routers if r.state != "Stopped"]
self.assertEqual(isinstance(self.routers, list), True,
"Check for list routers response return valid data")
self.assertEqual(len(self.routers), count,
"Check that %s routers were indeed created" % count)
def test_01_list_routers_admin(self):
"""TS_BUG_007-Check listRouters() using Admin User
"""
# Validate the following
# 1. PreReq: have rounters that are owned by other account
# 2. Create domain and create accounts in that domain
# 3. Create one VM for each account
# 4. Using Admin , run listRouters. It should return all the routers
vm_1 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.admin_account.name,
domainid=self.admin_account.domainid,
serviceofferingid=self.service_offering.id
)
self.debug("Deployed VM with ID: %s" % vm_1.id)
vm_2 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.user_account.name,
domainid=self.user_account.domainid,
serviceofferingid=self.service_offering.id
)
self.debug("Deployed VM with ID: %s" % vm_2.id)
routers = list_routers(
self.apiclient,
account=self.admin_account.name,
domainid=self.admin_account.domainid,
)
self.assertEqual(
isinstance(routers, list),
True,
"Check list response returns a valid list"
)
# ListRouter Should return 2 records
self.assertEqual(
len(routers),
1,
"Check list router response"
)
for router in routers:
self.assertEqual(
router.state,
'Running',
"Check list router response for router state"
)
return
def test_01_list_routers_admin(self):
"""TS_BUG_007-Check listRouters() using Admin User
"""
# Validate the following
# 1. PreReq: have rounters that are owned by other account
# 2. Create domain and create accounts in that domain
# 3. Create one VM for each account
# 4. Using Admin , run listRouters. It should return all the routers
vm_1 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.admin_account.name,
domainid=self.admin_account.domainid,
serviceofferingid=self.service_offering.id
)
self.debug("Deployed VM with ID: %s" % vm_1.id)
vm_2 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.user_account.name,
domainid=self.user_account.domainid,
serviceofferingid=self.service_offering.id
)
self.debug("Deployed VM with ID: %s" % vm_2.id)
routers = list_routers(
self.apiclient,
account=self.admin_account.name,
domainid=self.admin_account.domainid,
)
self.assertEqual(
isinstance(routers, list),
True,
"Check list response returns a valid list"
)
# ListRouter Should return 2 records
self.assertEqual(
len(routers),
1,
"Check list router response"
)
for router in routers:
self.assertEqual(
router.state,
'Running',
"Check list router response for router state"
)
return
def query_routers(self, count=2, showall=False):
self.routers = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
)
if not showall:
self.routers = [r for r in self.routers if r.state != "Stopped"]
self.assertEqual(
isinstance(self.routers, list), True,
"Check for list routers response return valid data")
self.assertEqual(
len(self.routers), count,
"Check that %s routers were indeed created" % count)
def get_vpcrouter(self):
routers = list_routers(self.apiclient,
account=self.account.name,
domainid=self.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]
return router
def start_vpcrouter(self, router):
self.debug("Starting router ID: %s" % router.id)
cmd = startRouter.startRouterCmd()
cmd.id = router.id
self.apiclient.startRouter(cmd)
routers = list_routers(self.apiclient,
account=self.account.name,
domainid=self.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")
def test_router_common(self):
"""Performs common router tests and returns router public_ips"""
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(routers, list),
True,
"Check for list routers response return valid data"
)
self.assertTrue(
len(routers) >= 1,
"Check list router response"
)
router = routers[0]
self.assertEqual(
router.state,
'Running',
"Check list router response for router state"
)
public_ips = list_publicIP(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id
)
self.assertEqual(
isinstance(public_ips, list),
True,
"Check for list public IPs response return valid data"
)
self.assertTrue(
len(public_ips) >= 1,
"Check public IP list has at least one IP"
)
return public_ips
def test_02_reboot_router_after_addition_of_one_guest_network(self):
""" Test reboot of router after addition of one guest network
"""
# Validations
# 1. Create a VPC with cidr - 10.1.1.1/16
# 2. Add network1(10.1.1.1/24) to this VPC.
# 3. Deploy vm1,vm2 and vm3 such that they are part of network1.
# 4. Create a PF /Static Nat/LB rule for vms in network1.
# 5. Create ingress network ACL for allowing all the above rules from a public ip range on network1.
# 6. Create egress network ACL for network1 to access google.com.
# 7. Create a private gateway for this VPC and add a static route to this gateway.
# 8. Create a VPN gateway for this VPC and add a static route to this gateway.
# 9. Make sure that all the PF,LB and Static NAT rules work as expected.
# 10. Make sure that we are able to access google.com from all the user Vms.
# 11. Make sure that the newly added private gateway's and VPN
# gateway's static routes work as expected
self.validate_vpc_offering(self.vpc_off)
self.validate_vpc_network(self.vpc)
self.assertEqual(
isinstance(self.gateways, list), True,
"List private gateways should return a valid response")
self.assertEqual(isinstance(self.static_routes, list), True,
"List static route should return a valid response")
routers = Router.list(self.api_client,
account=self.account.name,
domainid=self.account.domainid,
listall=True)
self.assertEqual(isinstance(routers, list), True,
"List Routers should return a valid list")
router = routers[0]
self.debug("Rebooting the router ...")
# Reboot the router
cmd = rebootRouter.rebootRouterCmd()
cmd.id = router.id
self.api_client.rebootRouter(cmd)
# List routers to check state of router
router_response = list_routers(self.api_client, id=router.id)
self.assertEqual(isinstance(router_response, list), True,
"Check list response returns a valid list")
# List router should have router in running state and same public IP
self.assertEqual(router_response[0].state, 'Running',
"Check list router response for router state")
return
def test_02_reboot_router_after_creating_vpc(self):
""" Test to reboot the router after creating a VPC
"""
# Validate the following
# 1. Create a VPC with cidr - 10.1.1.1/16
# 2. Reboot the VPC Virtual Router which is created as a result of VPC creation.
# Stop the VPC Router
self.validate_vpc_offering(self.vpc_off)
self.validate_vpc_network(self.vpc)
routers = Router.list(
self.api_client,
account=self.account.name,
domainid=self.account.domainid,
listall=True
)
self.assertEqual(
isinstance(routers, list),
True,
"List Routers should return a valid list"
)
router = routers[0]
self.debug("Rebooting the router ...")
# Reboot the router
cmd = rebootRouter.rebootRouterCmd()
cmd.id = router.id
self.api_client.rebootRouter(cmd)
# List routers to check state of router
router_response = list_routers(
self.api_client,
id=router.id
)
self.assertEqual(
isinstance(router_response, list),
True,
"Check list response returns a valid list"
)
# List router should have router in running state and same public IP
self.assertEqual(
router_response[0].state,
'Running',
"Check list router response for router state"
)
return
def migrate_router(self, router):
""" Migrate the router """
self.debug("Checking if the host is available for migration?")
hosts = Host.list(self.api_client, zoneid=self.zone.id, type='Routing')
self.assertEqual(isinstance(hosts, list), True,
"List hosts should return a valid list")
if len(hosts) < 2:
self.skipTest(
"No host available for migration. Test requires atleast 2 hosts"
)
# Remove the host of current VM from the hosts list
hosts[:] = [host for host in hosts if host.id != router.hostid]
host = hosts[0]
self.debug("Validating if the network rules work properly or not?")
self.debug("Migrating VM-ID: %s from %s to Host: %s" %
(router.id, router.hostid, host.id))
try:
# Migrate the router
cmd = migrateSystemVm.migrateSystemVmCmd()
cmd.isAsync = "false"
cmd.hostid = host.id
cmd.virtualmachineid = router.id
self.api_client.migrateSystemVm(cmd)
except Exception as e:
self.fail("Failed to migrate instance, %s" % e)
self.debug("Waiting for Router mgiration ....")
time.sleep(240)
# List routers to check state of router
router_response = list_routers(self.api_client, id=router.id)
self.assertEqual(isinstance(router_response, list), True,
"Check list response returns a valid list")
router.hostid = router_response[0].hostid
self.assertEqual(
router.hostid, host.id,
"Migration to host %s failed. The router host is"
"still %s" % (host.id, router.hostid))
return
def test_06_router_advanced(self):
"""Test router advanced setup
"""
# Validate the following
# 1. verify that listRouters returned a 'Running' router
# 2. router will have dns and gateway as in listZones, listVlanIpRanges
# 3. router will have guest,public and linklocal IPs
list_router_response = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(list_router_response, list), True,
"Check list response returns a valid list")
self.assertNotEqual(len(list_router_response), 0,
"Check list router response")
for router in list_router_response:
self.assertEqual(router.state, 'Running',
"Check list router response for router state")
zones = list_zones(self.apiclient, id=router.zoneid)
self.assertEqual(isinstance(zones, list), True,
"Check list response returns a valid list")
zone = zones[0]
self.assertEqual(router.dns1, zone.dns1,
"Compare DNS1 of router and zone")
self.assertEqual(router.dns2, zone.dns2,
"Compare DNS2 of router and zone")
self.assertEqual(hasattr(router, 'guestipaddress'), True,
"Check whether router has guest IP field")
self.assertEqual(hasattr(router, 'linklocalip'), True,
"Check whether router has link local IP field")
# Fetch corresponding ip ranges information from listVlanIpRanges
ipranges_response = list_vlan_ipranges(self.apiclient,
zoneid=router.zoneid)
self.assertEqual(isinstance(ipranges_response, list), True,
"Check list response returns a valid list")
iprange = ipranges_response[0]
self.assertEqual(
router.gateway, iprange.gateway,
"Check gateway with that of corresponding IP range")
return
def stop_vpcrouter(self):
router = self.get_vpcrouter()
self.debug("Stopping router ID: %s" % router.id)
cmd = stopRouter.stopRouterCmd()
cmd.id = router.id
self.apiclient.stopRouter(cmd)
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.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")
return router
def start_VPC_VRouter(self, router):
# Start the VPC Router
cmd = startRouter.startRouterCmd()
cmd.id = router.id
self.apiclient.startRouter(cmd)
routers = list_routers(self.apiclient,
account=self.account.name,
domainid=self.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"
)
def test_04_userdata_service_on_alias_IP(self):
"""Deploy guest vm in new CIDR and verify userdata service on alias ip
1.Deploy guest vm in new cidr
2.Verify userdata service(apache2) listens on alias ip in VR
"""
list_router_response = list_routers(self.apiclient,
zoneid=self.zone.id,
listall=True)
self.assertEqual(isinstance(list_router_response, list), True,
"Check list response returns a valid list")
router = list_router_response[0]
hosts = list_hosts(self.apiclient,
zoneid=router.zoneid,
type='Routing',
state='Up',
id=router.hostid)
self.assertEqual(isinstance(hosts, list), True,
"Check list host returns a valid list")
host = hosts[0]
self.debug("Router ID: %s, state: %s" % (router.id, router.state))
self.assertEqual(router.state, 'Running',
"Check list router response for router state")
port = self.testdata['configurableData']['host']["publicport"]
username = self.testdata['configurableData']['host']["username"]
password = self.testdata['configurableData']['host']["password"]
# SSH to host so that host key is saved in first
# attempt
SshClient(host.ipaddress, port, username, password)
proc = "apache2"
result = get_process_status(host.ipaddress, port, username, password,
router.linklocalip,
"netstat -atnp | grep %s" % proc)
res = str(result)
self.debug("userdata process status on VR: %s" % res)
self.assertNotEqual(
res.find(self.alias_ip + ":80 ") - 1,
"password service is not running on alias ip")
return
def stop_vpcrouter(self):
router = self.get_vpcrouter()
self.debug("Stopping router ID: %s" % router.id)
cmd = stopRouter.stopRouterCmd()
cmd.id = router.id
self.apiclient.stopRouter(cmd)
routers = list_routers(self.apiclient,
account=self.account.name,
domainid=self.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"
)
return router
def query_routers(self, count=2, showall=False):
self.logger.debug('query_routers count: %s, showall: %s' % (count, showall))
self.routers = list_routers(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
)
if not showall:
self.routers = [r for r in self.routers if r.state != "Stopped"]
self.logger.debug('query_routers routers: %s' % self.routers)
self.assertEqual(
isinstance(self.routers, list), True,
"Check for list routers response return valid data")
if len(self.routers) != count:
self.logger.debug("INVESTIGATE!! Check that %s routers were indeed created" % count)
while True:
time.sleep(1)
self.assertEqual(
len(self.routers), count,
"Check that %s routers were indeed created" % count)
def test_router_dhcp_opts(self):
"""Check that the /etc/dhcpopts.txt has entries for the"""
self.logger.debug("Starting test_router_dhcphosts...")
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
networkid=self.network1.id
)
self.assertEqual(
isinstance(routers, list),
True,
"Check for list routers response return valid data"
)
self.assertNotEqual(
len(routers),
0,
"Check list router response"
)
network1_router = routers[0]
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
networkid=self.network2.id
)
self.assertEqual(
isinstance(routers, list),
True,
"Check for list routers response return valid data"
)
self.assertNotEqual(
len(routers),
0,
"Check list router response"
)
network2_router = routers[0]
self.assertEqual(
network1_router.state,
'Running',
"Check list router response for router state"
)
self.assertEqual(
network2_router.state,
'Running',
"Check list router response for router state"
)
public_ips = list_publicIP(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id,
associatednetworkid=self.network1.id
)
self.assertEqual(
isinstance(public_ips, list),
True,
"Check for list public IPs response return valid data"
)
network1_public_ip = public_ips[0]
public_ips = list_publicIP(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id,
associatednetworkid=self.network2.id
)
self.assertEqual(
isinstance(public_ips, list),
True,
"Check for list public IPs response return valid data"
)
network2_public_ip = public_ips[0]
self.logger.debug("Creating Firewall rule for VM ID: %s" % self.vm_1.id)
FireWallRule.create(
self.apiclient,
ipaddressid=network1_public_ip.id,
protocol=self.services["natrule1"]["protocol"],
cidrlist=['0.0.0.0/0'],
startport=self.services["natrule1"]["publicport"],
endport=self.services["natrule1"]["publicport"]
)
self.logger.debug("Creating NAT rule for VM ID: %s" % self.vm_1.id)
# Create NAT rule
nat_rule1 = NATRule.create(
self.apiclient,
self.vm_1,
self.services["natrule1"],
network1_public_ip.id
)
self.logger.debug("Creating Firewall rule for VM ID: %s" % self.vm_2.id)
FireWallRule.create(
self.apiclient,
ipaddressid=network2_public_ip.id,
protocol=self.services["natrule2"]["protocol"],
cidrlist=['0.0.0.0/0'],
startport=self.services["natrule2"]["publicport"],
endport=self.services["natrule2"]["publicport"]
)
self.logger.debug("Creating NAT rule for VM ID: %s" % self.vm_2.id)
# Create NAT rule
nat_rule2 = NATRule.create(
self.apiclient,
self.vm_2,
self.services["natrule2"],
network2_public_ip.id
)
nat_rules = list_nat_rules(
self.apiclient,
id=nat_rule1.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"
)
nat_rules = list_nat_rules(
self.apiclient,
id=nat_rule2.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"
)
self.logger.debug("Testing DHCP options for VMs %s and %s" % (self.vm_1.id, self.vm_2.id))
self.test_dhcphopts(self.vm_2.nic[1].ipaddress, network1_router)
self.test_dhcphopts(self.vm_1.nic[0].ipaddress, network2_router)
return
def test_01_VRServiceFailureAlerting(self):
if self.zone.networktype == "Basic":
list_router_response = list_routers(
self.apiclient,
listall="true"
)
else:
list_router_response = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_router_response, list),
True,
"Check list response returns a valid list"
)
router = list_router_response[0]
self.debug("Router ID: %s, state: %s" % (router.id, router.state))
self.assertEqual(
router.state,
'Running',
"Check list router response for router state"
)
alertSubject = "Monitoring Service on VR " + router.name
if self.hypervisor.lower() in ('vmware', 'hyperv'):
result = get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
router.linklocalip,
"service dnsmasq stop",
hypervisor=self.hypervisor
)
else:
try:
hosts = list_hosts(
self.apiclient,
zoneid=router.zoneid,
type='Routing',
state='Up',
id=router.hostid
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check list host returns a valid list"
)
host = hosts[0]
result = get_process_status(
host.ipaddress,
22,
self.services["configurableData"]["host"]["username"],
self.services["configurableData"]["host"]["password"],
router.linklocalip,
"service apache2 stop"
)
except Exception as e:
raise Exception("Exception raised in getting host\
credentials: %s " % e)
res = str(result)
self.debug("apache process status: %s" % res)
configs = Configurations.list(
self.apiclient,
name='router.alerts.check.interval'
)
# Set the value for one more minute than
# actual range to be on safer side
waitingPeriod = (
int(configs[0].value) + 600) # in seconds
time.sleep(waitingPeriod)
# wait for (router.alerts.check.interval + 10) minutes meanwhile monitor service on
# VR starts the apache service (
# router.alerts.check.interval default value is
# 30minutes)
qresultset = self.dbclient.execute(
"select id from alert where subject = '%s' ORDER BY id DESC LIMIT 1;" %
str(alertSubject))
self.assertNotEqual(
len(qresultset),
0,
"Check DB Query result set"
)
return
def test_router_dhcphosts(self):
"""Check that the /etc/dhcphosts.txt doesn't contain duplicate IPs"""
self.logger.debug("Starting test_router_dhcphosts...")
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.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.assertEqual(
router.state,
'Running',
"Check list router response for router state"
)
public_ips = list_publicIP(
self.apiclient,
account=self.account.name,
domainid=self.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]
self.logger.debug("Creating Firewall rule for VM ID: %s" % self.vm_1.id)
FireWallRule.create(
self.apiclient,
ipaddressid=public_ip.id,
protocol=self.services["natrule1"]["protocol"],
cidrlist=['0.0.0.0/0'],
startport=self.services["natrule1"]["publicport"],
endport=self.services["natrule1"]["publicport"]
)
self.logger.debug("Creating NAT rule for VM ID: %s" % self.vm_1.id)
# Create NAT rule
nat_rule1 = NATRule.create(
self.apiclient,
self.vm_1,
self.services["natrule1"],
public_ip.id
)
self.logger.debug("Creating Firewall rule for VM ID: %s" % self.vm_2.id)
FireWallRule.create(
self.apiclient,
ipaddressid=public_ip.id,
protocol=self.services["natrule2"]["protocol"],
cidrlist=['0.0.0.0/0'],
startport=self.services["natrule2"]["publicport"],
endport=self.services["natrule2"]["publicport"]
)
self.logger.debug("Creating NAT rule for VM ID: %s" % self.vm_2.id)
# Create NAT rule
nat_rule2 = NATRule.create(
self.apiclient,
self.vm_2,
self.services["natrule2"],
public_ip.id
)
nat_rules = list_nat_rules(
self.apiclient,
id=nat_rule1.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"
)
nat_rules = list_nat_rules(
self.apiclient,
id=nat_rule2.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"
)
self.logger.debug("Testing SSH to VMs %s and %s" % (self.vm_1.id, self.vm_2.id))
self.test_ssh_command(self.vm_1, nat_rule1, "natrule1")
self.test_ssh_command(self.vm_2, nat_rule2, "natrule2")
self.logger.debug("Testing DHCP hosts for VMs %s and %s" % (self.vm_1.id, self.vm_2.id))
self.test_dhcphosts(self.vm_1, router)
self.test_dhcphosts(self.vm_2, router)
self.logger.debug("Deleting and Expunging VM %s with ip %s" % (self.vm_1.id, self.vm_1.nic[0].ipaddress))
self.vm_1.delete(self.apiclient)
self.logger.debug("Creating new VM using the same IP as the one which was deleted => IP 10.1.1.50")
self.vm_1 = VirtualMachine.create(self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.domain.id,
serviceofferingid=self.service_offering.id,
networkids=[str(self.network.id)],
ipaddress="10.1.1.50")
self.cleanup.append(self.vm_1)
self.logger.debug("Testing DHCP hosts for VMs %s and %s" % (self.vm_1.id, self.vm_2.id))
self.test_dhcphosts(self.vm_1, router)
self.test_dhcphosts(self.vm_2, router)
return
def test_04_restart_network_wo_cleanup(self):
"""Test restart network without cleanup
"""
# Validate the following
# 1. When cleanup = false, router is restarted and
# all services inside the router are restarted
# 2. check 'uptime' to see if the actual restart happened
timeout = 10
# Network should be in Implemented or Setup stage before restart
while True:
networks = list_networks(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(networks, list),
True,
"Check list response returns a valid list"
)
network = networks[0]
if network.state in ["Implemented", "Setup"]:
break
elif timeout == 0:
break
else:
time.sleep(self.services["sleep"])
timeout = timeout - 1
self.debug(
"Restarting network with ID: %s, Network state: %s" % (
network.id,
network.state
))
cmd = restartNetwork.restartNetworkCmd()
cmd.id = network.id
cmd.cleanup = False
self.apiclient.restartNetwork(cmd)
# Get router details after restart
list_router_response = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_router_response, list),
True,
"Check list response returns a valid list"
)
router = list_router_response[0]
hosts = list_hosts(
self.apiclient,
zoneid=router.zoneid,
type='Routing',
state='Up',
id=router.hostid
)
self.assertEqual(
isinstance(hosts, list),
True,
"Check list response returns a valid list"
)
host = hosts[0]
if self.hypervisor.lower() in ('vmware', 'hyperv'):
res = get_process_status(
self.apiclient.connection.mgtSvr,
22,
self.apiclient.connection.user,
self.apiclient.connection.passwd,
router.linklocalip,
"uptime",
hypervisor=self.hypervisor
)
else:
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
res = get_process_status(
host.ipaddress,
22,
host.user,
host.passwd,
router.linklocalip,
"uptime"
)
except KeyError:
self.skipTest(
"Marvin configuration has no host credentials\
to check router services")
# res = 12:37:14 up 1 min, 0 users, load average: 0.61, 0.22, 0.08
# Split result to check the uptime
result = res[0].split()
self.debug("Router Uptime: %s" % result)
self.assertEqual(
str(result[1]),
'up',
"Check router is running or not"
)
if str(result[3]) == "min,":
self.assertEqual(
(int(result[2]) < 3),
True,
"Check uptime is less than 3 mins or not"
)
else:
self.assertEqual(
str(result[3]),
'sec,',
"Check uptime is in seconds"
)
return
def test_delete_account(self):
"""Test for delete account"""
# Validate the Following
# 1. after account.cleanup.interval (global setting)
# time all the PF/LB rules should be deleted
# 2. verify that list(LoadBalancer/PortForwarding)Rules
# API does not return any rules for the account
# 3. The domR should have been expunged for this account
self.account.delete(self.apiclient)
interval = list_configurations(
self.apiclient,
name='account.cleanup.interval'
)
self.assertEqual(
isinstance(interval, list),
True,
"Check if account.cleanup.interval config present"
)
# Sleep to ensure that all resources are deleted
time.sleep(int(interval[0].value))
# ListLoadBalancerRules should not list
# associated rules with deleted account
# Unable to find account testuser1 in domain 1 : Exception
try:
list_lb_rules(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
except CloudstackAPIException:
self.debug("Port Forwarding Rule is deleted")
# ListPortForwardingRules should not
# list associated rules with deleted account
try:
list_nat_rules(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
except CloudstackAPIException:
self.debug("NATRule is deleted")
# Retrieve router for the user account
try:
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
routers,
None,
"Check routers are properly deleted."
)
except CloudstackAPIException:
self.debug("Router is deleted")
except Exception as e:
raise Exception(
"Encountered %s raised while fetching routers for account: %s" %
(e, self.account.name))
return
def test_isolate_network_password_server(self):
"""Check the password file in the Router VM"""
self.logger.debug("Starting test_isolate_network_password_server...")
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.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.assertEqual(
router.state,
'Running',
"Check list router response for router state"
)
public_ips = list_publicIP(
self.apiclient,
account=self.account.name,
domainid=self.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]
self.logger.debug("Creating Firewall rule for VM ID: %s" % self.vm_1.id)
FireWallRule.create(
self.apiclient,
ipaddressid=public_ip.id,
protocol=self.services["natrule1"]["protocol"],
cidrlist=['0.0.0.0/0'],
startport=self.services["natrule1"]["publicport"],
endport=self.services["natrule1"]["publicport"]
)
self.logger.debug("Creating NAT rule for VM ID: %s" % self.vm_1.id)
# Create NAT rule
nat_rule1 = NATRule.create(
self.apiclient,
self.vm_1,
self.services["natrule1"],
public_ip.id
)
self.logger.debug("Creating Firewall rule for VM ID: %s" % self.vm_2.id)
FireWallRule.create(
self.apiclient,
ipaddressid=public_ip.id,
protocol=self.services["natrule2"]["protocol"],
cidrlist=['0.0.0.0/0'],
startport=self.services["natrule2"]["publicport"],
endport=self.services["natrule2"]["publicport"]
)
self.logger.debug("Creating NAT rule for VM ID: %s" % self.vm_2.id)
# Create NAT rule
nat_rule2 = NATRule.create(
self.apiclient,
self.vm_2,
self.services["natrule2"],
public_ip.id
)
nat_rules = list_nat_rules(
self.apiclient,
id=nat_rule1.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"
)
nat_rules = list_nat_rules(
self.apiclient,
id=nat_rule2.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"
)
self.test_ssh_command(self.vm_1, nat_rule1, "natrule1")
self.test_ssh_command(self.vm_2, nat_rule2, "natrule2")
self.test_password_file_not_empty(self.vm_1, router)
self.test_password_file_not_empty(self.vm_2, router)
return
def test_reboot_router(self):
"""Test for reboot router"""
# Validate the Following
# 1. Post restart PF and LB rules should still function
# 2. verify if the ssh into the virtual machine
# still works through the sourceNAT Ip
# Retrieve router for the user account
self.debug("Public IP: %s" % self.vm_1.ssh_ip)
self.debug("Public IP: %s" % self.public_ip.ipaddress.ipaddress)
routers = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(routers, list),
True,
"Check list routers returns a valid list"
)
router = routers[0]
self.debug("Rebooting the router (ID: %s)" % router.id)
cmd = rebootRouter.rebootRouterCmd()
cmd.id = router.id
self.apiclient.rebootRouter(cmd)
# Poll listVM to ensure VM is stopped properly
timeout = self.services["timeout"]
while True:
time.sleep(self.services["sleep"])
# Ensure that VM is in stopped state
list_vm_response = list_virtual_machines(
self.apiclient,
id=self.vm_1.id
)
if isinstance(list_vm_response, list):
vm = list_vm_response[0]
if vm.state == 'Running':
self.debug("VM state: %s" % vm.state)
break
if timeout == 0:
raise Exception(
"Failed to start VM (ID: %s) in change service offering" %
vm.id)
timeout = timeout - 1
# we should be able to SSH after successful reboot
try:
self.debug("SSH into VM (ID : %s ) after reboot" % self.vm_1.id)
SshClient(
self.public_ip.ipaddress.ipaddress,
self.services["natrule"]["publicport"],
self.vm_1.username,
self.vm_1.password
)
except Exception as e:
self.fail(
"SSH Access failed for %s: %s" %
(self.public_ip.ipaddress.ipaddress, e))
return
def test_05_router_basic(self):
"""Test router basic setup
"""
# Validate the following:
# 1. verify that listRouters returned a 'Running' router
# 2. router will have dns same as that seen in listZones
# 3. router will have a guestIP and a linkLocalIp"
list_router_response = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_router_response, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(list_router_response),
0,
"Check list router response"
)
for router in list_router_response:
self.assertEqual(
router.state,
'Running',
"Check list router response for router state"
)
zones = list_zones(
self.apiclient,
id=router.zoneid
)
self.assertEqual(
isinstance(zones, list),
True,
"Check list response returns a valid list"
)
zone = zones[0]
self.assertEqual(
router.dns1,
zone.dns1,
"Compare DNS1 of router and zone"
)
self.assertEqual(
router.dns2,
zone.dns2,
"Compare DNS2 of router and zone"
)
self.assertEqual(
hasattr(router, 'guestipaddress'),
True,
"Check whether router has guest IP field"
)
self.assertEqual(
hasattr(router, 'linklocalip'),
True,
"Check whether router has link local IP field"
)
return
def test_01_restart_network_cleanup(self):
"""TS_BUG_008-Test restart network
"""
# Validate the following
# 1. When cleanup = true, router is destroyed and a new one created
# 2. New router will have new publicIp and linkLocalIp and
# all it's services should resume
# Find router associated with user account
list_router_response = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_router_response, list),
True,
"Check list response returns a valid list"
)
router = list_router_response[0]
#Store old values before restart
old_linklocalip = router.linklocalip
timeout = 10
# Network should be in Implemented or Setup stage before restart
while True:
networks = Network.list(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
network = networks[0]
if network.state in ["Implemented", "Setup"]:
break
elif timeout == 0:
break
else:
time.sleep(60)
timeout = timeout - 1
self.debug("Restarting network: %s" % network.id)
cmd = restartNetwork.restartNetworkCmd()
cmd.id = network.id
cmd.cleanup = True
self.apiclient.restartNetwork(cmd)
# Get router details after restart
list_router_response = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_router_response, list),
True,
"Check list response returns a valid list"
)
router = list_router_response[0]
self.assertNotEqual(
router.linklocalip,
old_linklocalip,
"Check link-local IP after restart"
)
return
def test_06_router_advanced(self):
"""Test router advanced setup
"""
# Validate the following
# 1. verify that listRouters returned a 'Running' router
# 2. router will have dns and gateway as in listZones, listVlanIpRanges
# 3. router will have guest,public and linklocal IPs
list_router_response = list_routers(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_router_response, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(list_router_response),
0,
"Check list router response"
)
for router in list_router_response:
self.assertEqual(
router.state,
'Running',
"Check list router response for router state"
)
zones = list_zones(
self.apiclient,
id=router.zoneid
)
self.assertEqual(
isinstance(zones, list),
True,
"Check list response returns a valid list"
)
zone = zones[0]
self.assertEqual(
router.dns1,
zone.dns1,
"Compare DNS1 of router and zone"
)
self.assertEqual(
router.dns2,
zone.dns2,
"Compare DNS2 of router and zone"
)
self.assertEqual(
hasattr(router, 'guestipaddress'),
True,
"Check whether router has guest IP field"
)
self.assertEqual(
hasattr(router, 'linklocalip'),
True,
"Check whether router has link local IP field"
)
# Fetch corresponding ip ranges information from listVlanIpRanges
ipranges_response = list_vlan_ipranges(
self.apiclient,
zoneid=router.zoneid
)
self.assertEqual(
isinstance(ipranges_response, list),
True,
"Check list response returns a valid list"
)
iprange = ipranges_response[0]
self.assertEqual(
router.gateway,
iprange.gateway,
"Check gateway with that of corresponding IP range"
)
return
