| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| |
| """ Component tests VM life cycle in VPC network functionality |
| """ |
| #Import Local Modules |
| from nose.plugins.attrib import attr |
| from marvin.cloudstackTestCase import cloudstackTestCase |
| import unittest |
| from marvin.cloudstackAPI import migrateSystemVm |
| from marvin.lib.utils import cleanup_resources |
| from marvin.lib.base import (Host, |
| VirtualMachine, |
| ServiceOffering, |
| VPC, |
| VpcOffering, |
| Router, |
| Network, |
| NetworkOffering, |
| Cluster, |
| Account) |
| from marvin.lib.common import (get_domain, |
| get_zone, |
| get_template, |
| wait_for_cleanup) |
| import time |
| |
| |
| class Services: |
| """Test VM life cycle in VPC network services |
| """ |
| |
| def __init__(self): |
| self.services = { |
| "account": { |
| "email": "test@test.com", |
| "firstname": "Test", |
| "lastname": "User", |
| "username": "test", |
| # Random characters are appended for unique |
| # username |
| "password": "password", |
| }, |
| "service_offering": { |
| "name": "Tiny Instance", |
| "displaytext": "Tiny Instance", |
| "cpunumber": 1, |
| "cpuspeed": 100, |
| "memory": 64, |
| }, |
| "service_offering_1": { |
| "name": "Tiny Instance- tagged host 1", |
| "displaytext": "Tiny off-tagged host2", |
| "cpunumber": 1, |
| "cpuspeed": 100, |
| "memory": 64, |
| "hosttags": "hosttag1" |
| }, |
| "service_offering_2": { |
| "name": "Tiny Instance- tagged host 2", |
| "displaytext": "Tiny off-tagged host2", |
| "cpunumber": 1, |
| "cpuspeed": 100, |
| "memory": 64, |
| "hosttags": "hosttag2" |
| }, |
| "network_offering": { |
| "name": 'VPC Network offering', |
| "displaytext": 'VPC Network off', |
| "guestiptype": 'Isolated', |
| "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Lb,UserData,StaticNat,NetworkACL', |
| "traffictype": 'GUEST', |
| "availability": 'Optional', |
| "useVpc": 'on', |
| "serviceProviderList": { |
| "Dhcp": 'VpcVirtualRouter', |
| "Dns": 'VpcVirtualRouter', |
| "SourceNat": 'VpcVirtualRouter', |
| "PortForwarding": 'VpcVirtualRouter', |
| "Lb": 'VpcVirtualRouter', |
| "UserData": 'VpcVirtualRouter', |
| "StaticNat": 'VpcVirtualRouter', |
| "NetworkACL": 'VpcVirtualRouter' |
| }, |
| }, |
| "network_offering_no_lb": { |
| "name": 'VPC Network offering', |
| "displaytext": 'VPC Network off', |
| "guestiptype": 'Isolated', |
| "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,UserData,StaticNat,NetworkACL', |
| "traffictype": 'GUEST', |
| "availability": 'Optional', |
| "useVpc": 'on', |
| "serviceProviderList": { |
| "Dhcp": 'VpcVirtualRouter', |
| "Dns": 'VpcVirtualRouter', |
| "SourceNat": 'VpcVirtualRouter', |
| "PortForwarding": 'VpcVirtualRouter', |
| "UserData": 'VpcVirtualRouter', |
| "StaticNat": 'VpcVirtualRouter', |
| "NetworkACL": 'VpcVirtualRouter' |
| }, |
| }, |
| "network_off_shared": { |
| "name": 'Shared Network offering', |
| "displaytext": 'Shared Network offering', |
| "guestiptype": 'Shared', |
| "traffictype": 'GUEST', |
| "availability": 'Optional', |
| "useVpc": 'on', |
| "specifyIpRanges": True, |
| "specifyVlan": True |
| }, |
| "vpc_offering": { |
| "name": 'VPC off', |
| "displaytext": 'VPC off', |
| "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Lb,UserData,StaticNat', |
| }, |
| "vpc": { |
| "name": "TestVPC", |
| "displaytext": "TestVPC", |
| "cidr": '10.0.0.1/24' |
| }, |
| "network": { |
| "name": "Test Network", |
| "displaytext": "Test Network", |
| "netmask": '255.255.255.0', |
| "limit": 5, |
| # Max networks allowed as per hypervisor |
| # Xenserver -> 5, VMWare -> 9 |
| }, |
| "lbrule": { |
| "name": "SSH", |
| "alg": "leastconn", |
| # Algorithm used for load balancing |
| "privateport": 22, |
| "publicport": 2222, |
| "openfirewall": False, |
| "startport": 2222, |
| "endport": 2222, |
| "protocol": "TCP", |
| "cidrlist": '0.0.0.0/0', |
| }, |
| "natrule": { |
| "privateport": 22, |
| "publicport": 22, |
| "startport": 22, |
| "endport": 22, |
| "protocol": "TCP", |
| "cidrlist": '0.0.0.0/0', |
| }, |
| "fw_rule": { |
| "startport": 1, |
| "endport": 6000, |
| "cidr": '0.0.0.0/0', |
| # Any network (For creating FW rule) |
| "protocol": "TCP" |
| }, |
| "http_rule": { |
| "startport": 80, |
| "endport": 80, |
| "cidrlist": '0.0.0.0/0', |
| "protocol": "ICMP" |
| }, |
| "virtual_machine": { |
| "displayname": "Test VM", |
| "username": "root", |
| "password": "password", |
| "ssh_port": 22, |
| "hypervisor": 'XenServer', |
| # Hypervisor type should be same as |
| # hypervisor type of cluster |
| "privateport": 22, |
| "publicport": 22, |
| "protocol": 'TCP', |
| "userdata": 'This is sample data', |
| }, |
| "ostype": 'CentOS 5.3 (64-bit)', |
| # Cent OS 5.3 (64 bit) |
| "sleep": 60, |
| "timeout": 30, |
| "mode": 'advanced' |
| } |
| |
| |
| class TestVMLifeCycleHostmaintenance(cloudstackTestCase): |
| |
| @classmethod |
| def setUpClass(cls): |
| cls.testClient = super(TestVMLifeCycleHostmaintenance, cls).getClsTestClient() |
| cls.api_client = cls.testClient.getApiClient() |
| |
| cls.services = Services().services |
| # Get Zone, Domain and templates |
| cls.domain = get_domain(cls.api_client) |
| cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) |
| cls.template = get_template( |
| cls.api_client, |
| cls.zone.id, |
| cls.services["ostype"] |
| ) |
| cls.hypervisor = cls.testClient.getHypervisorInfo() |
| if cls.hypervisor.lower() in ['lxc']: |
| raise unittest.SkipTest("Template creation from root volume is not supported in LXC") |
| cls.services["virtual_machine"]["zoneid"] = cls.zone.id |
| cls.services["virtual_machine"]["template"] = cls.template.id |
| |
| clusterWithSufficientHosts = None |
| clusters = Cluster.list(cls.api_client, zoneid=cls.zone.id) |
| for cluster in clusters: |
| cls.hosts = Host.list(cls.api_client, clusterid=cluster.id) |
| if len(cls.hosts) >= 2: |
| clusterWithSufficientHosts = cluster |
| break |
| |
| if clusterWithSufficientHosts is None: |
| raise unittest.SkipTest("No Cluster with 2 hosts found") |
| |
| Host.update(cls.api_client, id=cls.hosts[0].id, hosttags="hosttag1") |
| Host.update(cls.api_client, id=cls.hosts[1].id, hosttags="hosttag2") |
| |
| cls.service_offering_1 = ServiceOffering.create( |
| cls.api_client, |
| cls.services["service_offering_1"] |
| ) |
| cls.service_offering_2 = ServiceOffering.create( |
| cls.api_client, |
| cls.services["service_offering_2"] |
| ) |
| cls.vpc_off = VpcOffering.create( |
| cls.api_client, |
| cls.services["vpc_offering"] |
| ) |
| cls.vpc_off.update(cls.api_client, state='Enabled') |
| |
| cls.account = Account.create( |
| cls.api_client, |
| cls.services["account"], |
| admin=True, |
| domainid=cls.domain.id |
| ) |
| |
| cls.vpc_off = VpcOffering.create( |
| cls.api_client, |
| cls.services["vpc_offering"] |
| ) |
| |
| cls.vpc_off.update(cls.api_client, state='Enabled') |
| |
| cls.services["vpc"]["cidr"] = '10.1.1.1/16' |
| cls.vpc = VPC.create( |
| cls.api_client, |
| cls.services["vpc"], |
| vpcofferingid=cls.vpc_off.id, |
| zoneid=cls.zone.id, |
| account=cls.account.name, |
| domainid=cls.account.domainid |
| ) |
| |
| cls.nw_off = NetworkOffering.create( |
| cls.api_client, |
| cls.services["network_offering"], |
| conservemode=False |
| ) |
| # Enable Network offering |
| cls.nw_off.update(cls.api_client, state='Enabled') |
| |
| # Creating network using the network offering created |
| cls.network_1 = Network.create( |
| cls.api_client, |
| cls.services["network"], |
| accountid=cls.account.name, |
| domainid=cls.account.domainid, |
| networkofferingid=cls.nw_off.id, |
| zoneid=cls.zone.id, |
| gateway='10.1.1.1', |
| vpcid=cls.vpc.id |
| ) |
| cls.nw_off_no_lb = NetworkOffering.create( |
| cls.api_client, |
| cls.services["network_offering_no_lb"], |
| conservemode=False |
| ) |
| # Enable Network offering |
| cls.nw_off_no_lb.update(cls.api_client, state='Enabled') |
| |
| # Creating network using the network offering created |
| cls.network_2 = Network.create( |
| cls.api_client, |
| cls.services["network"], |
| accountid=cls.account.name, |
| domainid=cls.account.domainid, |
| networkofferingid=cls.nw_off_no_lb.id, |
| zoneid=cls.zone.id, |
| gateway='10.1.2.1', |
| vpcid=cls.vpc.id |
| ) |
| # Spawn an instance in that network |
| cls.vm_1 = VirtualMachine.create( |
| cls.api_client, |
| cls.services["virtual_machine"], |
| accountid=cls.account.name, |
| domainid=cls.account.domainid, |
| serviceofferingid=cls.service_offering_1.id, |
| networkids=[str(cls.network_1.id)] |
| ) |
| # Spawn an instance in that network |
| cls.vm_2 = VirtualMachine.create( |
| cls.api_client, |
| cls.services["virtual_machine"], |
| accountid=cls.account.name, |
| domainid=cls.account.domainid, |
| serviceofferingid=cls.service_offering_1.id, |
| networkids=[str(cls.network_1.id)] |
| ) |
| cls.vm_3 = VirtualMachine.create( |
| cls.api_client, |
| cls.services["virtual_machine"], |
| accountid=cls.account.name, |
| domainid=cls.account.domainid, |
| serviceofferingid=cls.service_offering_2.id, |
| networkids=[str(cls.network_2.id)] |
| ) |
| routers = Router.list( |
| cls.api_client, |
| account=cls.account.name, |
| domainid=cls.account.domainid, |
| listall=True |
| ) |
| if isinstance(routers, list): |
| cls.vpcvr = routers[0] |
| |
| cls._cleanup = [ |
| cls.service_offering_1, |
| cls.service_offering_2, |
| cls.nw_off, |
| cls.nw_off_no_lb, |
| ] |
| return |
| |
| @classmethod |
| def tearDownClass(cls): |
| try: |
| #Delete the host tags |
| Host.update(cls.api_client, id=cls.hosts[0].id, hosttags="") |
| Host.update(cls.api_client, id=cls.hosts[1].id, hosttags="") |
| cls.account.delete(cls.api_client) |
| wait_for_cleanup(cls.api_client, ["account.cleanup.interval"]) |
| #Cleanup resources used |
| cleanup_resources(cls.api_client, cls._cleanup) |
| cls.vpc_off.delete(cls.api_client) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| def setUp(self): |
| |
| self.apiclient = self.testClient.getApiClient() |
| self.dbclient = self.testClient.getDbConnection() |
| self.debug("Check the status of VPC virtual router") |
| routers = Router.list( |
| self.apiclient, |
| networkid=self.network_1.id, |
| listall=True |
| ) |
| if not isinstance(routers, list): |
| raise Exception("No response from list routers API") |
| |
| self.router = routers[0] |
| if self.router.state == "Running": |
| self.debug("Verified that the Router is in Running State") |
| |
| self.cleanup = [] |
| return |
| |
| def tearDown(self): |
| try: |
| #Clean up, terminate the created network offerings |
| cleanup_resources(self.apiclient, self.cleanup) |
| except Exception as e: |
| raise Exception("Warning: Exception during cleanup : %s" % e) |
| return |
| |
| def validate_vm_deployment(self): |
| """Validates VM deployment on different hosts""" |
| |
| vms = VirtualMachine.list( |
| self.apiclient, |
| account=self.account.name, |
| domainid=self.account.domainid, |
| networkid=self.network_1.id, |
| listall=True |
| ) |
| self.assertEqual( |
| isinstance(vms, list), |
| True, |
| "List VMs shall return a valid response" |
| ) |
| host_1 = vms[0].hostid |
| self.debug("Host for network 1: %s" % vms[0].hostid) |
| |
| vms = VirtualMachine.list( |
| self.apiclient, |
| account=self.account.name, |
| domainid=self.account.domainid, |
| networkid=self.network_2.id, |
| listall=True |
| ) |
| self.assertEqual( |
| isinstance(vms, list), |
| True, |
| "List VMs shall return a valid response" |
| ) |
| host_2 = vms[0].hostid |
| self.debug("Host for network 2: %s" % vms[0].hostid) |
| |
| self.assertNotEqual( |
| host_1, |
| host_2, |
| "Both the virtual machines should be deployed on diff hosts " |
| ) |
| return |
| |
| @attr(tags=["advanced", "intervlan"]) |
| def test_01_enable_maintenance_with_vpc_nw(self): |
| """ Test enable Maintenance Mode on Hosts which have VPC elements |
| """ |
| |
| # Validate the following |
| # 1. Create a VPC with cidr - 10.1.1.1/16 |
| # 2. Add network1(10.1.1.1/24) and network2(10.1.2.1/24) to this VPC. |
| # 3. Deploy vm1 and vm2 in network1 and vm3 and vm4 in network2. Make |
| # sure vm1 and vm3 are deployed on one host in the cluster while |
| # vm2 and vm4 are deployed on the other host in the cluster. This |
| # can be done using host's tags & service offerings with host tags |
| # Steps: |
| # 1.Enable Maintenance on one of host on which VPCVR is present |
| # Validations: |
| # 1. Successfully push the host into maintenance mode. |
| # 2. VMs present on the above host should successfully migrate to the |
| # other host present in the cluster |
| |
| Host.update(self.apiclient, id=self.hosts[0].id, hosttags="hosttag1,hosttag2") |
| Host.update(self.apiclient, id=self.hosts[1].id, hosttags="hosttag1,hosttag2") |
| |
| self.validate_vm_deployment() |
| self.debug("Stop the host on which the VPC virtual router is running") |
| try: |
| Host.enableMaintenance(self.apiclient, id=self.vpcvr.hostid) |
| except Exception as e: |
| self.fail("Failed to enable maintenance mode on host: %s" % e) |
| |
| self.debug( |
| "Check if all instances belonging to the account are up again?") |
| routers = Router.list( |
| self.apiclient, |
| account=self.account.name, |
| domainid=self.account.domainid, |
| listall=True |
| ) |
| self.assertEqual( |
| isinstance(routers, list), |
| True, |
| "List routers shall return a valid VPCVR for account" |
| ) |
| |
| router = routers[0] |
| |
| try: |
| |
| timeout = self.services["timeout"] |
| self.debug("Timeout Value %d : " % timeout) |
| while True: |
| list_router_response = Router.list( |
| self.apiclient, |
| id = router.id, |
| state = "Running" |
| ) |
| |
| if list_router_response is not None: |
| break |
| elif timeout == 0: |
| raise Exception("Router state should be running after migration") |
| |
| time.sleep(self.services["sleep"]) |
| timeout = timeout - 1 |
| self.debug("Waiting for %d seconds - %d tries left" % (self.services["sleep"],timeout)) |
| |
| self.debug("Verified that the Router is in Running State") |
| |
| except Exception as e: |
| self.fail("Failed to find the Router in Running state %s " % e) |
| |
| vms = VirtualMachine.list( |
| self.apiclient, |
| account=self.account.name, |
| domainid=self.account.domainid, |
| listall=True |
| ) |
| self.assertEqual( |
| isinstance(vms, list), |
| True, |
| "VM response should return instances running for account" |
| ) |
| for vm in vms: |
| self.assertEqual( |
| vm.state, |
| "Running", |
| "Vm state should be running after migration" |
| ) |
| return |
| |
| @attr(tags=["advanced", "intervlan"]) |
| def test_02_cancel_maintenance(self): |
| """ Test cancel Maintenance Mode on the above Hosts + Migrate VMs Back |
| """ |
| |
| # Steps |
| # 1. Cancel Maintenance Mode on the host. |
| # 2. Migrate the VMs back onto the host on which Maintenance mode is |
| # cancelled. |
| # Validate the following |
| # 1. Successfully cancel the Maintenance mode on the host. |
| # 2. Migrate the VMs back successfully onto the host. |
| # 3. Check that the network connectivity exists with the migrated VMs. |
| |
| try: |
| timeout = self.services["timeout"] |
| while True: |
| list_host_response = Host.list( |
| self.apiclient, |
| id=self.vpcvr.hostid, |
| resourcestate="Maintenance") |
| |
| if list_host_response is not None: |
| break |
| elif timeout == 0: |
| raise Exception("Failed to list the Host in Maintenance State") |
| |
| time.sleep(self.services["sleep"]) |
| timeout = timeout - 1 |
| |
| self.debug("Verified that the Host is in Maintenance State") |
| |
| except: |
| self.fail("Failed to find the Host in maintenance state") |
| |
| self.debug("Cancel host maintenence on which the VPCVR is running") |
| try: |
| Host.cancelMaintenance(self.apiclient, id=self.vpcvr.hostid) |
| |
| timeout = self.services["timeout"] |
| while True: |
| list_host_response = Host.list( |
| self.apiclient, |
| id=self.vpcvr.hostid, |
| state="Up") |
| |
| if list_host_response is not None: |
| break |
| elif timeout == 0: |
| raise Exception("Failed to list the Host in Up State after Canceling Maintenance Mode") |
| |
| time.sleep(self.services["sleep"]) |
| timeout = timeout - 1 |
| |
| self.debug("Verified that the Host is in Up State after Canceling Maintenance Mode") |
| |
| except Exception as e: |
| self.fail("Failed to cancel maintenance mode on host: %s" % e) |
| |
| self.debug( |
| "Migrating the instances back to the host: %s" % |
| self.vpcvr.hostid) |
| try: |
| cmd = migrateSystemVm.migrateSystemVmCmd() |
| cmd.hostid = self.vpcvr.hostid |
| cmd.virtualmachineid = self.vpcvr.id |
| self.apiclient.migrateSystemVm(cmd) |
| except Exception as e: |
| self.fail("Failed to migrate VPCVR back: %s" % e) |
| |
| self.debug("Check the status of router after migration") |
| routers = Router.list( |
| self.apiclient, |
| id=self.vpcvr.id, |
| listall=True |
| ) |
| self.assertEqual( |
| isinstance(routers, list), |
| True, |
| "List routers shall return the valid response" |
| ) |
| self.assertEqual( |
| routers[0].state, |
| "Running", |
| "Router state should be running" |
| ) |
| # TODO: Check for the network connectivity |
| return |
| |
| @attr(tags=["advanced", "intervlan"]) |
| def test_03_reconnect_host(self): |
| """ Test reconnect Host which has VPC elements |
| """ |
| |
| # Steps: |
| # 1.Reconnect one of the host on which VPC Virtual Router is present. |
| # Validate the following |
| # 1. Host should successfully reconnect. |
| # 2. Network connectivity to all the VMs on the host should not be |
| # effected due to reconnection. |
| |
| try: |
| timeout = self.services["timeout"] |
| while True: |
| list_host_response = Host.list( |
| self.apiclient, |
| id=self.vpcvr.hostid, |
| resourcestate="Enabled") |
| |
| if list_host_response is not None: |
| break |
| elif timeout == 0: |
| raise Exception("Failed to list the Host in Up State") |
| |
| time.sleep(self.services["sleep"]) |
| timeout = timeout - 1 |
| |
| self.debug("Verified that the Host is in Up State") |
| |
| except: |
| self.fail("Failed to find the Host in Up State") |
| |
| self.debug("Reconnecting the host where VPC VR is running") |
| try: |
| Host.reconnect(self.apiclient, id=self.vpcvr.hostid) |
| except Exception as e: |
| self.fail("Failed to reconnect to host: %s" % e) |
| |
| self.debug("Check the status of router after migration") |
| routers = Router.list( |
| self.apiclient, |
| id=self.vpcvr.id, |
| listall=True |
| ) |
| self.assertEqual( |
| isinstance(routers, list), |
| True, |
| "List routers shall return the valid response" |
| ) |
| self.assertEqual( |
| routers[0].state, |
| "Running", |
| "Router state should be running" |
| ) |
| # TODO: Check for the network connectivity |
| return |
