| # Licensed to the Apache Software Foundation (ASF) under one | |
| # or more contributor license agreements. See the NOTICE file | |
| # distributed with this work for additional information | |
| # regarding copyright ownership. The ASF licenses this file | |
| # to you under the Apache License, Version 2.0 (the | |
| # "License"); you may not use this file except in compliance | |
| # with the License. You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, | |
| # software distributed under the License is distributed on an | |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| # KIND, either express or implied. See the License for the | |
| # specific language governing permissions and limitations | |
| # under the License. | |
| """ P1 tests for routers | |
| """ | |
| # Import Local Modules | |
| from nose.plugins.attrib import attr | |
| from marvin.cloudstackTestCase import cloudstackTestCase | |
| from marvin.cloudstackAPI import (stopVirtualMachine, | |
| stopRouter, | |
| startRouter, | |
| getRouterHealthCheckResults) | |
| from marvin.lib.utils import (cleanup_resources, | |
| get_process_status) | |
| from marvin.lib.base import (ServiceOffering, | |
| VirtualMachine, | |
| Account, | |
| LoadBalancerRule, | |
| FireWallRule, | |
| NATRule) | |
| from marvin.lib.common import (get_zone, | |
| get_template, | |
| get_domain, | |
| list_virtual_machines, | |
| list_networks, | |
| list_configurations, | |
| list_routers, | |
| list_nat_rules, | |
| list_publicIP, | |
| list_lb_rules, | |
| list_firewall_rules, | |
| list_hosts) | |
| # Import System modules | |
| import time | |
| class TestRouterServices(cloudstackTestCase): | |
| @classmethod | |
| def setUpClass(cls): | |
| cls.testClient = super(TestRouterServices, cls).getClsTestClient() | |
| cls.api_client = cls.testClient.getApiClient() | |
| cls.services = cls.testClient.getParsedTestDataConfig() | |
| # Get Zone, Domain and templates | |
| cls.domain = get_domain(cls.api_client) | |
| cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) | |
| cls.services['mode'] = cls.zone.networktype | |
| cls.template = get_template( | |
| cls.api_client, | |
| cls.zone.id, | |
| cls.services["ostype"] | |
| ) | |
| cls.services["virtual_machine"]["zoneid"] = cls.zone.id | |
| # Create an account, network, VM and IP addresses | |
| cls.account = Account.create( | |
| cls.api_client, | |
| cls.services["account"], | |
| admin=True, | |
| domainid=cls.domain.id | |
| ) | |
| cls.service_offering = ServiceOffering.create( | |
| cls.api_client, | |
| cls.services["service_offering"] | |
| ) | |
| cls.vm_1 = VirtualMachine.create( | |
| cls.api_client, | |
| cls.services["virtual_machine"], | |
| templateid=cls.template.id, | |
| accountid=cls.account.name, | |
| domainid=cls.account.domainid, | |
| serviceofferingid=cls.service_offering.id | |
| ) | |
| cls.vm_2 = VirtualMachine.create( | |
| cls.api_client, | |
| cls.services["virtual_machine"], | |
| templateid=cls.template.id, | |
| accountid=cls.account.name, | |
| domainid=cls.account.domainid, | |
| serviceofferingid=cls.service_offering.id | |
| ) | |
| cls._cleanup = [ | |
| cls.account, | |
| cls.service_offering | |
| ] | |
| return | |
| @classmethod | |
| def tearDownClass(cls): | |
| try: | |
| cls.api_client = super( | |
| TestRouterServices, | |
| cls).getClsTestClient().getApiClient() | |
| # Clean up, terminate the created templates | |
| cleanup_resources(cls.api_client, cls._cleanup) | |
| except Exception as e: | |
| raise Exception("Warning: Exception during cleanup : %s" % e) | |
| return | |
| def tearDown(self): | |
| try: | |
| cleanup_resources(self.apiclient, self.cleanup) | |
| except Exception as e: | |
| raise Exception("Warning: Exception during cleanup : %s" % e) | |
| return | |
| def setUp(self): | |
| self.apiclient = self.testClient.getApiClient() | |
| self.cleanup = [] | |
| return | |
| @attr(tags=["advanced"], required_hardware="false") | |
| def test_01_AdvancedZoneRouterServices(self): | |
| """Test advanced zone router services | |
| """ | |
| # Validate the following: | |
| # 1. Verify that list of services provided by this network are running | |
| # a. DNS | |
| # b. DHCP | |
| # c. Gateway | |
| # d. Firewall | |
| # e. LB | |
| # f. VPN | |
| # g. userdata | |
| # 2. wait for router to start and guest network to be created | |
| # a. listRouters account=user, domainid=1 (router state=Running) | |
| # b. listNetworks account=user domainid=1 | |
| # (network state=Implemented) | |
| # c. listVirtualMachines account=user domainid=1 (VM state=Running) | |
| # 3. listNetwork | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.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" | |
| ) | |
| for router in routers: | |
| self.debug("Router ID: %s & Router state: %s" % ( | |
| router.id, | |
| router.state | |
| )) | |
| self.assertEqual( | |
| router.state, | |
| 'Running', | |
| "Router state is not running but is %s" % router.state | |
| ) | |
| # Network state associated with account should be 'Implemented' | |
| networks = list_networks( | |
| self.apiclient, | |
| account=self.account.name, | |
| domainid=self.account.domainid, | |
| type='Isolated' | |
| ) | |
| self.assertEqual( | |
| isinstance(networks, list), | |
| True, | |
| "Check for list networks response return valid data" | |
| ) | |
| self.assertNotEqual( | |
| len(networks), | |
| 0, | |
| "Check list networks response" | |
| ) | |
| for network in networks: | |
| self.debug("Network ID: %s & Network state: %s" % ( | |
| network.id, | |
| network.state | |
| )) | |
| self.assertIn( | |
| network.state, | |
| ['Implemented', 'Allocated'], | |
| "Check list network response for network state" | |
| ) | |
| # VM state associated with account should be 'Running' | |
| virtual_machines = list_virtual_machines( | |
| self.apiclient, | |
| account=self.account.name, | |
| domainid=self.account.domainid | |
| ) | |
| self.assertEqual( | |
| isinstance(virtual_machines, list), | |
| True, | |
| "Check for list virtual machines response return valid data" | |
| ) | |
| self.assertNotEqual( | |
| len(virtual_machines), | |
| 0, | |
| "Check list virtual machines response" | |
| ) | |
| for virtual_machine in virtual_machines: | |
| self.assertEqual( | |
| virtual_machine.state, | |
| 'Running', | |
| "Check list VM response for Running state" | |
| ) | |
| self.debug("VM ID: %s & VM state: %s" % ( | |
| virtual_machine.id, | |
| virtual_machine.state | |
| )) | |
| # Check status of DNS, DHCP, FIrewall, LB VPN processes | |
| networks = list_networks( | |
| self.apiclient, | |
| account=self.account.name, | |
| domainid=self.account.domainid, | |
| type='Isolated' | |
| ) | |
| self.assertEqual( | |
| isinstance(networks, list), | |
| True, | |
| "Check for list networks response return valid data" | |
| ) | |
| self.assertNotEqual( | |
| len(networks), | |
| 0, | |
| "Check list networks response" | |
| ) | |
| # Load Balancer, Userdata, VPN, Firewall, Gateway, DNS processes should | |
| # be running | |
| for network in networks: | |
| self.assertEqual( | |
| 'Lb' in str(network.service), | |
| True, | |
| "Check Load balancing process in list networks" | |
| ) | |
| self.assertEqual( | |
| 'UserData' in str(network.service), | |
| True, | |
| "Check UserData service in list networks" | |
| ) | |
| self.assertEqual( | |
| 'Vpn' in str(network.service), | |
| True, | |
| "Check Vpn service in list networks" | |
| ) | |
| self.assertEqual( | |
| 'Firewall' in str(network.service), | |
| True, | |
| "Check Firewall service in list networks" | |
| ) | |
| self.assertEqual( | |
| 'Dns' in str(network.service), | |
| True, | |
| "Check Dns service in list networks" | |
| ) | |
| return | |
| @attr(configuration="network.gc") | |
| @attr(tags=["advanced"], required_hardware="false") | |
| def test_02_NetworkGarbageCollection(self): | |
| """Test network garbage collection | |
| """ | |
| # Validate the following | |
| # 1. wait for router to start and guest network to be created | |
| # a.listRouters account=user, domainid=1 (router state=Running) | |
| # b.listNetworks account=user domainid=1 (network state=Implemented) | |
| # c.listVirtualMachines account=user domainid=1 (VM states=Running) | |
| # 4. stopVirtualMachines (stop all VMs in this account) | |
| # 5. wait for VMs to stop-listVirtualMachines account=user, domainid=1 | |
| # (Both VM states = Stopped) | |
| # 6. wait for network.gc.interval*2 seconds (600s) | |
| # 7. listRouters account=user, domainid=1 | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.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 associated with account should be in running state | |
| timeout = 180 | |
| router = routers[0] | |
| self.debug("Router ID: %s & Router state: %s" % ( | |
| router.id, | |
| router.state | |
| )) | |
| self.debug( | |
| "Wait for %s secs max for router to reach Running state" % | |
| timeout) | |
| while timeout: | |
| time.sleep(60) | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.name, | |
| domainid=self.account.domainid, | |
| id=router.id) | |
| router = routers[0] | |
| if router.state == 'Running': | |
| break | |
| timeout = timeout - 60 | |
| if timeout == 0: | |
| self.assertEqual( | |
| router.state, | |
| 'Running', | |
| "Router not in Running state") | |
| # Network state associated with account should be 'Implemented' | |
| networks = list_networks( | |
| self.apiclient, | |
| account=self.account.name, | |
| domainid=self.account.domainid, | |
| type='Isolated' | |
| ) | |
| self.assertEqual( | |
| isinstance(networks, list), | |
| True, | |
| "Check for list networks response return valid data" | |
| ) | |
| self.assertNotEqual( | |
| len(networks), | |
| 0, | |
| "Check list networks response" | |
| ) | |
| # Check if network in 'Implemented' state | |
| for network in networks: | |
| self.debug("Network ID: %s & Network state: %s" % ( | |
| network.id, | |
| network.state | |
| )) | |
| self.assertIn( | |
| network.state, | |
| ['Implemented', 'Allocated'], | |
| "Check list network response for network state" | |
| ) | |
| # VM state associated with account should be 'Running' | |
| virtual_machines = list_virtual_machines( | |
| self.apiclient, | |
| account=self.account.name, | |
| domainid=self.account.domainid, | |
| ) | |
| self.assertEqual( | |
| isinstance(virtual_machines, list), | |
| True, | |
| "Check for list virtual machines response return valid data" | |
| ) | |
| self.assertNotEqual( | |
| len(virtual_machines), | |
| 0, | |
| "Check list virtual machines response" | |
| ) | |
| for virtual_machine in virtual_machines: | |
| self.debug("VM ID: %s & VM state: %s" % ( | |
| virtual_machine.id, | |
| virtual_machine.state | |
| )) | |
| self.assertEqual( | |
| virtual_machine.state, | |
| 'Running', | |
| "Check list VM response for Running state" | |
| ) | |
| # Stop virtual machine | |
| cmd = stopVirtualMachine.stopVirtualMachineCmd() | |
| cmd.id = virtual_machine.id | |
| self.apiclient.stopVirtualMachine(cmd) | |
| gcinterval = list_configurations( | |
| self.apiclient, | |
| name='network.gc.interval' | |
| ) | |
| self.assertEqual( | |
| isinstance(gcinterval, list), | |
| True, | |
| "Check for list intervals response return valid data" | |
| ) | |
| self.debug("network.gc.interval: %s" % gcinterval[0].value) | |
| gcwait = list_configurations( | |
| self.apiclient, | |
| name='network.gc.wait' | |
| ) | |
| self.assertEqual( | |
| isinstance(gcwait, list), | |
| True, | |
| "Check for list intervals response return valid data" | |
| ) | |
| self.debug("network.gc.wait: %s" % gcwait[0].value) | |
| total_wait = int(gcinterval[0].value) + int(gcwait[0].value) | |
| # Router is stopped after (network.gc.interval *2) time. Wait for | |
| # (network.gc.interval+network.gc.wait) * 2 for moving | |
| # router to 'Stopped' | |
| time.sleep(total_wait * 2) | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.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" | |
| ) | |
| for router in routers: | |
| self.debug("Router ID: %s & Router state: %s" % ( | |
| router.id, | |
| router.state | |
| )) | |
| self.assertEqual( | |
| router.state, | |
| 'Stopped', | |
| "Check list router response for router state" | |
| ) | |
| # Cleanup Vm_2 - Not required for further tests | |
| self.cleanup.append(self.vm_2) | |
| return | |
| @attr(tags=["advanced"], required_hardware="false") | |
| def test_03_RouterStartOnVmDeploy(self): | |
| """Test router start on VM deploy | |
| """ | |
| # Validate the following | |
| # 1. deployVirtualMachine in the account | |
| # 2. listVirtualMachines account=user, domainid=1 | |
| # 3. when listVirtualMachines reports the userVM to be in state=Running | |
| # 4. listRouters should report router to have come back to "Running" | |
| # state | |
| # 5. All other VMs in the account should remain in "Stopped" state | |
| # stop all pre-existing virtual machines if they are in 'Running' state | |
| virtual_machines = list_virtual_machines( | |
| self.apiclient, | |
| account=self.account.name, | |
| domainid=self.account.domainid, | |
| ) | |
| self.assertEqual( | |
| isinstance(virtual_machines, list), | |
| True, | |
| "Check for list virtual machines response return valid data" | |
| ) | |
| self.assertNotEqual( | |
| len(virtual_machines), | |
| 0, | |
| "Check list virtual machines response" | |
| ) | |
| for virtual_machine in virtual_machines: | |
| self.debug("VM ID: %s & VM state: %s" % ( | |
| virtual_machine.id, | |
| virtual_machine.state | |
| )) | |
| if virtual_machine.state == 'Running': | |
| # Stop virtual machine | |
| cmd = stopVirtualMachine.stopVirtualMachineCmd() | |
| cmd.id = virtual_machine.id | |
| self.apiclient.stopVirtualMachine(cmd) | |
| vm = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machine"], | |
| templateid=self.template.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| serviceofferingid=self.service_offering.id | |
| ) | |
| self.debug("Deployed a VM with ID: %s" % vm.id) | |
| virtual_machines = list_virtual_machines( | |
| self.apiclient, | |
| id=vm.id, | |
| account=self.account.name, | |
| domainid=self.account.domainid, | |
| ) | |
| self.assertEqual( | |
| isinstance(virtual_machines, list), | |
| True, | |
| "Check for list virtual machines response return valid data" | |
| ) | |
| self.assertNotEqual( | |
| len(virtual_machines), | |
| 0, | |
| "Check list virtual machines response" | |
| ) | |
| # VM state should be 'Running' | |
| for virtual_machine in virtual_machines: | |
| self.assertEqual( | |
| virtual_machine.state, | |
| 'Running', | |
| "Check list VM response for Running state" | |
| ) | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.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" | |
| ) | |
| # Routers associated with account should be 'Running' after deployment | |
| # of VM | |
| for router in routers: | |
| self.debug("Router ID: %s & Router state: %s" % ( | |
| router.id, | |
| router.state | |
| )) | |
| self.assertEqual( | |
| router.state, | |
| 'Running', | |
| "Check list router response for router state" | |
| ) | |
| # All other VMs (VM_1) should be in 'Stopped' | |
| virtual_machines = list_virtual_machines( | |
| self.apiclient, | |
| id=self.vm_1.id, | |
| account=self.account.name, | |
| domainid=self.account.domainid, | |
| ) | |
| self.assertEqual( | |
| isinstance(virtual_machines, list), | |
| True, | |
| "Check for list VMs response return valid data" | |
| ) | |
| self.assertNotEqual( | |
| len(virtual_machines), | |
| 0, | |
| "Check list virtual machines response" | |
| ) | |
| for virtual_machine in virtual_machines: | |
| self.debug("VM ID: %s & VM state: %s" % ( | |
| virtual_machine.id, | |
| virtual_machine.state | |
| )) | |
| self.assertEqual( | |
| virtual_machine.state, | |
| 'Stopped', | |
| "Check list VM response for Stopped state" | |
| ) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_04_RouterHealthChecksResults(self): | |
| """Test advanced zone router list contains health check records | |
| """ | |
| 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.api_client.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) | |
| 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 | |
| ) | |
| class TestRouterStopCreatePF(cloudstackTestCase): | |
| @classmethod | |
| def setUpClass(cls): | |
| cls.testClient = super(TestRouterStopCreatePF, cls).getClsTestClient() | |
| cls.api_client = cls.testClient.getApiClient() | |
| cls.services = cls.testClient.getParsedTestDataConfig() | |
| # Get Zone, Domain and templates | |
| cls.domain = get_domain(cls.api_client) | |
| cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) | |
| cls.services['mode'] = cls.zone.networktype | |
| template = get_template( | |
| cls.api_client, | |
| cls.zone.id, | |
| cls.services["ostype"] | |
| ) | |
| cls.services["virtual_machine"]["zoneid"] = cls.zone.id | |
| # Create an account, network, VM and IP addresses | |
| cls.account = Account.create( | |
| cls.api_client, | |
| cls.services["account"], | |
| admin=True, | |
| domainid=cls.domain.id | |
| ) | |
| cls.service_offering = ServiceOffering.create( | |
| cls.api_client, | |
| cls.services["service_offering"] | |
| ) | |
| cls.vm_1 = VirtualMachine.create( | |
| cls.api_client, | |
| cls.services["virtual_machine"], | |
| templateid=template.id, | |
| accountid=cls.account.name, | |
| domainid=cls.account.domainid, | |
| serviceofferingid=cls.service_offering.id | |
| ) | |
| cls._cleanup = [ | |
| cls.account, | |
| cls.service_offering | |
| ] | |
| return | |
| @classmethod | |
| def tearDownClass(cls): | |
| try: | |
| cls.api_client = super( | |
| TestRouterStopCreatePF, | |
| cls).getClsTestClient().getApiClient() | |
| # Clean up, terminate the created resources | |
| cleanup_resources(cls.api_client, cls._cleanup) | |
| except Exception as e: | |
| raise Exception("Warning: Exception during cleanup : %s" % e) | |
| return | |
| def tearDown(self): | |
| try: | |
| # Clean up, terminate the created resources | |
| cleanup_resources(self.apiclient, self.cleanup) | |
| except Exception as e: | |
| raise Exception("Warning: Exception during cleanup : %s" % e) | |
| return | |
| def setUp(self): | |
| self.apiclient = self.testClient.getApiClient() | |
| self.cleanup = [] | |
| return | |
| @attr(tags=["advanced", "advancedns"], required_hardware="true") | |
| def test_01_RouterStopCreatePF(self): | |
| """Test router stop create port forwarding | |
| """ | |
| # validate the following | |
| # 1. wait for router to start, guest network to be implemented and | |
| # VM to report Running | |
| # 2. stopRouter for this account | |
| # 3. wait for listRouters to report Router as 'Stopped' | |
| # 4. listPublicIpAddresses account=user, domainid=1 - pick ipaddressid | |
| # 5. createPortForwardingRule (ipaddressid from step 5.) | |
| # a. for port 22 (ssh) for user VM deployed in step 1. | |
| # b. public port 22 , private port 22 | |
| # 6. startRouter stopped for this account | |
| # 7. wait for listRouters to show router as Running | |
| # Get router details associated for that account | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.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.debug("Stopping router ID: %s" % router.id) | |
| # Stop the router | |
| cmd = stopRouter.stopRouterCmd() | |
| cmd.id = router.id | |
| self.apiclient.stopRouter(cmd) | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.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" | |
| ) | |
| 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] | |
| # Open up firewall port for SSH | |
| FireWallRule.create( | |
| self.apiclient, | |
| ipaddressid=public_ip.id, | |
| protocol=self.services["natrule"]["protocol"], | |
| cidrlist=['0.0.0.0/0'], | |
| startport=self.services["natrule"]["publicport"], | |
| endport=self.services["natrule"]["publicport"] | |
| ) | |
| self.debug("Creating NAT rule for VM ID: %s" % self.vm_1.id) | |
| # Create NAT rule | |
| nat_rule = NATRule.create( | |
| self.apiclient, | |
| self.vm_1, | |
| self.services["natrule"], | |
| public_ip.id | |
| ) | |
| self.debug("Starting router ID: %s" % router.id) | |
| # Start the router | |
| cmd = startRouter.startRouterCmd() | |
| cmd.id = router.id | |
| self.apiclient.startRouter(cmd) | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.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" | |
| ) | |
| # NAT Rule should be in Active state after router start | |
| nat_rules = list_nat_rules( | |
| self.apiclient, | |
| id=nat_rule.id | |
| ) | |
| self.assertEqual( | |
| isinstance(nat_rules, list), | |
| True, | |
| "Check for list NAT rules response return valid data" | |
| ) | |
| self.assertEqual( | |
| nat_rules[0].state, | |
| 'Active', | |
| "Check list port forwarding rules" | |
| ) | |
| try: | |
| self.debug("SSH into VM with ID: %s" % nat_rule.ipaddress) | |
| self.vm_1.get_ssh_client( | |
| ipaddress=nat_rule.ipaddress, | |
| port=self.services["natrule"]["publicport"]) | |
| except Exception as e: | |
| self.fail( | |
| "SSH Access failed for %s: %s" % | |
| (nat_rule.ipaddress, e) | |
| ) | |
| return | |
| class TestRouterStopCreateLB(cloudstackTestCase): | |
| @classmethod | |
| def setUpClass(cls): | |
| cls.testClient = super(TestRouterStopCreateLB, cls).getClsTestClient() | |
| cls.api_client = cls.testClient.getApiClient() | |
| cls.services = cls.testClient.getParsedTestDataConfig() | |
| # Get Zone, Domain and templates | |
| cls.domain = get_domain(cls.api_client) | |
| cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) | |
| cls.services['mode'] = cls.zone.networktype | |
| template = get_template( | |
| cls.api_client, | |
| cls.zone.id, | |
| cls.services["ostype"] | |
| ) | |
| cls.services["virtual_machine"]["zoneid"] = cls.zone.id | |
| # Create an account, network, VM and IP addresses | |
| cls.account = Account.create( | |
| cls.api_client, | |
| cls.services["account"], | |
| admin=True, | |
| domainid=cls.domain.id | |
| ) | |
| cls.service_offering = ServiceOffering.create( | |
| cls.api_client, | |
| cls.services["service_offering"] | |
| ) | |
| cls.vm_1 = VirtualMachine.create( | |
| cls.api_client, | |
| cls.services["virtual_machine"], | |
| templateid=template.id, | |
| accountid=cls.account.name, | |
| domainid=cls.account.domainid, | |
| serviceofferingid=cls.service_offering.id | |
| ) | |
| cls._cleanup = [ | |
| cls.account, | |
| cls.service_offering | |
| ] | |
| return | |
| @classmethod | |
| def tearDownClass(cls): | |
| try: | |
| cls.api_client = super( | |
| TestRouterStopCreateLB, | |
| cls).getClsTestClient().getApiClient() | |
| # Clean up, terminate the created resources | |
| cleanup_resources(cls.api_client, cls._cleanup) | |
| except Exception as e: | |
| raise Exception("Warning: Exception during cleanup : %s" % e) | |
| return | |
| def tearDown(self): | |
| try: | |
| cleanup_resources(self.apiclient, self.cleanup) | |
| except Exception as e: | |
| raise Exception("Warning: Exception during cleanup : %s" % e) | |
| return | |
| def setUp(self): | |
| self.apiclient = self.testClient.getApiClient() | |
| self.cleanup = [] | |
| return | |
| @attr(tags=["advanced", "advancedns"], required_hardware="true") | |
| def test_01_RouterStopCreateLB(self): | |
| """Test router stop create Load balancing | |
| """ | |
| # validate the following | |
| # 1. listLoadBalancerRules (publicipid=ipaddressid of source NAT) | |
| # 2. rule should be for port 22 as applied and | |
| # should be in state=Active | |
| # 3. ssh access should be allowed to the userVMs over the source NAT IP | |
| # and port 22 | |
| # Get router details associated for that account | |
| 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.debug("Stopping router with ID: %s" % router.id) | |
| # Stop the router | |
| cmd = stopRouter.stopRouterCmd() | |
| cmd.id = router.id | |
| self.apiclient.stopRouter(cmd) | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.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" | |
| ) | |
| public_ips = list_publicIP( | |
| self.apiclient, | |
| account=self.account.name, | |
| domainid=self.account.domainid | |
| ) | |
| self.assertEqual( | |
| isinstance(public_ips, list), | |
| True, | |
| "Check for list public IPs response return valid data" | |
| ) | |
| public_ip = public_ips[0] | |
| # Open up firewall port for SSH | |
| FireWallRule.create( | |
| self.apiclient, | |
| ipaddressid=public_ip.id, | |
| protocol=self.services["lbrule"]["protocol"], | |
| cidrlist=['0.0.0.0/0'], | |
| startport=self.services["lbrule"]["publicport"], | |
| endport=self.services["lbrule"]["publicport"] | |
| ) | |
| self.debug("Creating LB rule for public IP: %s" % public_ip.id) | |
| # Create Load Balancer rule and assign VMs to rule | |
| lb_rule = LoadBalancerRule.create( | |
| self.apiclient, | |
| self.services["lbrule"], | |
| public_ip.id, | |
| accountid=self.account.name | |
| ) | |
| self.debug("Assigning VM %s to LB rule: %s" % ( | |
| self.vm_1.id, | |
| lb_rule.id | |
| )) | |
| lb_rule.assign(self.apiclient, [self.vm_1]) | |
| # Start the router | |
| cmd = startRouter.startRouterCmd() | |
| cmd.id = router.id | |
| self.apiclient.startRouter(cmd) | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.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, | |
| 'Running', | |
| "Check list router response for router state" | |
| ) | |
| # After router start, LB RUle should be in Active state | |
| lb_rules = list_lb_rules( | |
| self.apiclient, | |
| id=lb_rule.id | |
| ) | |
| self.assertEqual( | |
| isinstance(lb_rules, list), | |
| True, | |
| "Check for list LB rules response return valid data" | |
| ) | |
| self.assertEqual( | |
| lb_rules[0].state, | |
| 'Active', | |
| "Check list load balancing rules" | |
| ) | |
| self.assertEqual( | |
| lb_rules[0].publicport, | |
| str(self.services["lbrule"]["publicport"]), | |
| "Check list load balancing rules" | |
| ) | |
| try: | |
| self.debug("SSH into VM with IP: %s" % public_ip.ipaddress) | |
| self.vm_1.ssh_port = self.services["lbrule"]["publicport"] | |
| self.vm_1.get_ssh_client(public_ip.ipaddress) | |
| except Exception as e: | |
| self.fail( | |
| "SSH Access failed for %s: %s" % | |
| (self.vm_1.ipaddress, e) | |
| ) | |
| return | |
| class TestRouterStopCreateFW(cloudstackTestCase): | |
| @classmethod | |
| def setUpClass(cls): | |
| cls.testClient = super(TestRouterStopCreateFW, cls).getClsTestClient() | |
| cls.api_client = cls.testClient.getApiClient() | |
| cls.services = cls.testClient.getParsedTestDataConfig() | |
| # Get Zone, Domain and templates | |
| cls.domain = get_domain(cls.api_client) | |
| cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) | |
| cls.services['mode'] = cls.zone.networktype | |
| template = get_template( | |
| cls.api_client, | |
| cls.zone.id, | |
| cls.services["ostype"] | |
| ) | |
| cls.services["virtual_machine"]["zoneid"] = cls.zone.id | |
| # Create an account, network, VM and IP addresses | |
| cls.account = Account.create( | |
| cls.api_client, | |
| cls.services["account"], | |
| domainid=cls.domain.id | |
| ) | |
| cls.hostConfig = cls.config.__dict__["zones"][0].__dict__["pods"][0].__dict__["clusters"][0].__dict__["hosts"][0].__dict__ | |
| cls.service_offering = ServiceOffering.create( | |
| cls.api_client, | |
| cls.services["service_offering"] | |
| ) | |
| cls.vm_1 = VirtualMachine.create( | |
| cls.api_client, | |
| cls.services["virtual_machine"], | |
| templateid=template.id, | |
| accountid=cls.account.name, | |
| domainid=cls.account.domainid, | |
| serviceofferingid=cls.service_offering.id | |
| ) | |
| cls._cleanup = [ | |
| cls.account, | |
| cls.service_offering | |
| ] | |
| return | |
| @classmethod | |
| def tearDownClass(cls): | |
| try: | |
| cls.api_client = super( | |
| TestRouterStopCreateFW, | |
| cls).getClsTestClient().getApiClient() | |
| # Clean up, terminate the created templates | |
| cleanup_resources(cls.api_client, cls._cleanup) | |
| except Exception as e: | |
| raise Exception("Warning: Exception during cleanup : %s" % e) | |
| return | |
| def tearDown(self): | |
| try: | |
| cleanup_resources(self.apiclient, self.cleanup) | |
| except Exception as e: | |
| raise Exception("Warning: Exception during cleanup : %s" % e) | |
| return | |
| def setUp(self): | |
| self.apiclient = self.testClient.getApiClient() | |
| self.hypervisor = self.testClient.getHypervisorInfo() | |
| self.cleanup = [] | |
| return | |
| @attr(tags=["advanced", "advancedns"], required_hardware="true") | |
| def test_01_RouterStopCreateFW(self): | |
| """Test router stop create Firewall rule | |
| """ | |
| # validate the following | |
| # 1. 1. listFirewallRules (filter by ipaddressid of sourcenat) | |
| # 2. rule should be for ports 1-600 and in state=Active | |
| # (optional backend) | |
| # 3. verify on router using iptables -t nat -nvx if rules are applied | |
| # Get the router details associated with account | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.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.debug("Stopping the router: %s" % router.id) | |
| # Stop the router | |
| cmd = stopRouter.stopRouterCmd() | |
| cmd.id = router.id | |
| self.apiclient.stopRouter(cmd) | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.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" | |
| ) | |
| public_ips = list_publicIP( | |
| self.apiclient, | |
| account=self.account.name, | |
| domainid=self.account.domainid | |
| ) | |
| self.assertEqual( | |
| isinstance(public_ips, list), | |
| True, | |
| "Check for list public IP response return valid data" | |
| ) | |
| public_ip = public_ips[0] | |
| # Create Firewall rule with configurations from settings file | |
| fw_rule = FireWallRule.create( | |
| self.apiclient, | |
| ipaddressid=public_ip.id, | |
| protocol='TCP', | |
| cidrlist=[self.services["fwrule"]["cidr"]], | |
| startport=self.services["fwrule"]["startport"], | |
| endport=self.services["fwrule"]["endport"] | |
| ) | |
| self.debug("Created firewall rule: %s" % fw_rule.id) | |
| self.debug("Starting the router: %s" % router.id) | |
| # Start the router | |
| cmd = startRouter.startRouterCmd() | |
| cmd.id = router.id | |
| self.apiclient.startRouter(cmd) | |
| routers = list_routers( | |
| self.apiclient, | |
| account=self.account.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, | |
| 'Running', | |
| "Check list router response for router state" | |
| ) | |
| # After Router start, FW rule should be in Active state | |
| fw_rules = list_firewall_rules( | |
| self.apiclient, | |
| id=fw_rule.id, | |
| ) | |
| self.assertEqual( | |
| isinstance(fw_rules, list), | |
| True, | |
| "Check for list FW rules response return valid data" | |
| ) | |
| self.assertEqual( | |
| fw_rules[0].state, | |
| 'Active', | |
| "Check list load balancing rules" | |
| ) | |
| self.assertEqual( | |
| fw_rules[0].startport, | |
| self.services["fwrule"]["startport"], | |
| "Check start port of firewall rule" | |
| ) | |
| self.assertEqual( | |
| fw_rules[0].endport, | |
| self.services["fwrule"]["endport"], | |
| "Check end port of firewall rule" | |
| ) | |
| # For DNS and DHCP check 'dnsmasq' process status | |
| if (self.hypervisor.lower() == 'vmware' | |
| or self.hypervisor.lower() == 'hyperv'): | |
| result = get_process_status( | |
| self.apiclient.connection.mgtSvr, | |
| 22, | |
| self.apiclient.connection.user, | |
| self.apiclient.connection.passwd, | |
| router.linklocalip, | |
| 'iptables -t nat -L', | |
| hypervisor=self.hypervisor | |
| ) | |
| else: | |
| hosts = list_hosts( | |
| self.apiclient, | |
| id=router.hostid, | |
| ) | |
| self.assertEqual( | |
| isinstance(hosts, list), | |
| True, | |
| "Check for list hosts response return valid data" | |
| ) | |
| host = hosts[0] | |
| try: | |
| result = get_process_status( | |
| host.ipaddress, | |
| 22, | |
| self.hostConfig['username'], | |
| self.hostConfig['password'], | |
| router.linklocalip, | |
| 'iptables -t nat -L' | |
| ) | |
| except KeyError: | |
| self.skipTest( | |
| "Provide a marvin config file with host\ | |
| credentials to run %s" % | |
| self._testMethodName) | |
| self.debug("iptables -t nat -L: %s" % result) | |
| self.debug("Public IP: %s" % public_ip.ipaddress) | |
| res = str(result) | |
| self.assertEqual( | |
| res.count(str(public_ip.ipaddress)), | |
| 1, | |
| "Check public IP address" | |
| ) | |
| return |