| # 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. | |
| """ BVT tests for routers | |
| """ | |
| # Import Local Modules | |
| from marvin.codes import FAILED | |
| from marvin.cloudstackTestCase import cloudstackTestCase | |
| from marvin.cloudstackAPI import (stopRouter, | |
| restartNetwork, | |
| startRouter, | |
| rebootRouter, | |
| getRouterHealthCheckResults) | |
| from marvin.lib.utils import (cleanup_resources, | |
| get_process_status, | |
| get_host_credentials) | |
| from marvin.lib.base import (Account, | |
| ServiceOffering, | |
| VirtualMachine) | |
| from marvin.lib.common import (get_domain, | |
| get_zone, | |
| get_test_template, | |
| list_hosts, | |
| list_routers, | |
| list_networks, | |
| list_zones, | |
| list_vlan_ipranges) | |
| from nose.plugins.attrib import attr | |
| # Import System modules | |
| import time | |
| _multiprocess_shared_ = True | |
| class TestRouterServices(cloudstackTestCase): | |
| @classmethod | |
| def setUpClass(cls): | |
| testClient = super(TestRouterServices, cls).getClsTestClient() | |
| cls.apiclient = testClient.getApiClient() | |
| cls.services = testClient.getParsedTestDataConfig() | |
| # Get Zone, Domain and templates | |
| cls.domain = get_domain(cls.apiclient) | |
| cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) | |
| cls.hypervisor = testClient.getHypervisorInfo() | |
| cls.services['mode'] = cls.zone.networktype | |
| template = get_test_template( | |
| cls.apiclient, | |
| cls.zone.id, | |
| cls.hypervisor | |
| ) | |
| if template == FAILED: | |
| cls.fail("get_test_template() failed to return template") | |
| cls.services["virtual_machine"]["zoneid"] = cls.zone.id | |
| cls._cleanup = [] | |
| # Create an account, network, VM and IP addresses | |
| cls.account = Account.create( | |
| cls.apiclient, | |
| cls.services["account"], | |
| domainid=cls.domain.id | |
| ) | |
| cls._cleanup.append(cls.account) | |
| cls.service_offering = ServiceOffering.create( | |
| cls.apiclient, | |
| cls.services["service_offerings"]["tiny"] | |
| ) | |
| cls._cleanup.append(cls.service_offering) | |
| cls.vm_1 = VirtualMachine.create( | |
| cls.apiclient, | |
| cls.services["virtual_machine"], | |
| templateid=template.id, | |
| accountid=cls.account.name, | |
| domainid=cls.account.domainid, | |
| serviceofferingid=cls.service_offering.id | |
| ) | |
| cls._cleanup.append(cls.vm_1) | |
| return | |
| @classmethod | |
| def tearDownClass(cls): | |
| super(TestRouterServices, cls).tearDownClass() | |
| def setUp(self): | |
| self.apiclient = self.testClient.getApiClient() | |
| self.hypervisor = self.testClient.getHypervisorInfo() | |
| self.cleanup = [] | |
| def tearDown(self): | |
| super(TestRouterServices, self).tearDown() | |
| @attr(tags=["advanced", "basic", "sg", "smoke"], required_hardware="true") | |
| 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 | |
| @attr(tags=["advanced", "advancedns"], required_hardware="false") | |
| def test_02_router_internal_adv(self): | |
| """Test router internal advanced zone | |
| """ | |
| # Validate the following | |
| # 1. Router does dhcp, dns, gateway, LB, PF, FW | |
| # 2. verify that dhcp, dns ports are open on UDP | |
| # 3. dnsmasq, haproxy processes should be running | |
| # 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] | |
| 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] | |
| 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" | |
| ) | |
| 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 haproxy", | |
| 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 haproxy" | |
| ) | |
| except KeyError: | |
| self.skipTest( | |
| "Marvin configuration has no host credentials\ | |
| to check router services") | |
| res = str(result) | |
| self.assertEqual( | |
| res.count("active"), | |
| 1, | |
| "Check haproxy service is running or not" | |
| ) | |
| self.debug("Haproxy process status: %s" % res) | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.name, | |
| domainid=self.account.domainid, | |
| fetchhealthcheckresults=True | |
| ) | |
| 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.info("Router ID: %s & Router state: %s" % ( | |
| router.id, router.state | |
| )) | |
| self.assertEqual(isinstance(router.healthcheckresults, list), True, | |
| "Router response should contain it's health check result as list" | |
| ) | |
| cmd = getRouterHealthCheckResults.getRouterHealthCheckResultsCmd() | |
| cmd.routerid = router.id | |
| cmd.performfreshchecks = True # Perform fresh checks as a newly created router may not have results | |
| healthData = self.apiclient.getRouterHealthCheckResults(cmd) | |
| self.info("Router ID: %s & Router state: %s" % ( | |
| router.id, router.state | |
| )) | |
| self.assertEqual(router.id, healthData.routerid, | |
| "Router response should contain it's health check result so id should match" | |
| ) | |
| self.assertEqual(isinstance(healthData.healthchecks, list), True, | |
| "Router response should contain it's health check result as list" | |
| ) | |
| self.verifyCheckTypes(healthData.healthchecks) | |
| self.verifyCheckNames(healthData.healthchecks) | |
| self.verifyCheckResults(healthData.healthchecks) | |
| def verifyCheckTypes(self, healthChecks): | |
| for checkType in ["basic", "advanced"]: | |
| foundType = False | |
| for check in healthChecks: | |
| if check.checktype == checkType: | |
| foundType = True | |
| break | |
| self.assertTrue(foundType, | |
| "Router should contain health check results info for type: " + checkType | |
| ) | |
| def verifyCheckNames(self, healthChecks): | |
| for checkName in ["dns_check.py", "dhcp_check.py", "haproxy_check.py", "disk_space_check.py", "iptables_check.py", "gateways_check.py", "router_version_check.py"]: | |
| foundCheck = False | |
| for check in healthChecks: | |
| if check.checkname == checkName: | |
| foundCheck = True | |
| break | |
| self.assertTrue(foundCheck, | |
| "Router should contain health check results info for check name: " + checkName | |
| ) | |
| def verifyCheckResults(self, healthChecks): | |
| failedCheck = 0 | |
| for check in healthChecks: | |
| if check.success: | |
| print("check %s is good" % check.checkname) | |
| else: | |
| print("check %s failed due to %s" % (check.checkname, check.details)) | |
| failedCheck = failedCheck + 1 | |
| self.assertEquals(failedCheck, 0) | |
| @attr( | |
| tags=[ | |
| "advanced", | |
| "basic", | |
| "advancedns", | |
| "smoke", | |
| "dvs"], | |
| required_hardware="false") | |
| 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 | |
| if self.zone.networktype.lower() == "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] | |
| # Store old values before restart | |
| if self.zone.networktype.lower == "basic": | |
| old_publicip = router.guestipaddress | |
| else: | |
| 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 | |
| if self.zone.networktype.lower() == "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] | |
| if self.zone.networktype.lower() == "basic": | |
| new_publicip = router.guestipaddress | |
| else: | |
| new_publicip = router.publicip | |
| self.assertEqual( | |
| new_publicip, | |
| old_publicip, | |
| "Public IP of the router should remain same after network restart" | |
| ) | |
| return | |
| @attr(tags=["advanced", "advancedns", "smoke", "dvs"], required_hardware="true") | |
| 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]) < 20), | |
| True, | |
| "Check uptime is less than 20 mins or not" | |
| ) | |
| else: | |
| self.assertEqual( | |
| str(result[3]), | |
| 'sec,', | |
| "Check uptime is in seconds" | |
| ) | |
| return | |
| @attr(tags=["advanced", "advancedns", "smoke"], required_hardware="false") | |
| 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 Control IP field" | |
| ) | |
| return | |
| @attr(tags=["advanced", "advancedns", "smoke"], required_hardware="false") | |
| 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 Control 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 | |
| @attr(tags=["advanced", "advancedns", "smoke"], required_hardware="false") | |
| def test_07_stop_router(self): | |
| """Test stop 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("Stopping the router with ID: %s" % router.id) | |
| # Stop the router | |
| cmd = stopRouter.stopRouterCmd() | |
| cmd.id = router.id | |
| self.apiclient.stopRouter(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 stopped state | |
| self.assertEqual( | |
| router_response[0].state, | |
| 'Stopped', | |
| "Check list router response for router state" | |
| ) | |
| return | |
| @attr(tags=["advanced", "advancedns", "smoke"], required_hardware="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 verifyRouterResponse(self, router_response, ip): | |
| if (router_response) and (isinstance(router_response, list)) and \ | |
| (router_response[0].state == "Running") and \ | |
| (router_response[0].publicip == ip): | |
| return True | |
| return False | |
| @attr(tags=["advanced", "advancedns", "smoke", "dvs"], required_hardware="false") | |
| 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 | |
| @attr(tags=["advanced", "advancedns", "smoke", "dvs"], required_hardware="false") | |
| 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 |