Updated Branches: refs/heads/4.3 cd1956e40 -> 7bb7c08e1
Including tests for VPC VM Lifecycle on Tagged hosts Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/7bb7c08e Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/7bb7c08e Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/7bb7c08e Branch: refs/heads/4.3 Commit: 7bb7c08e10894727bcdfa7708170aab69a3aeeea Parents: cd1956e Author: Ashutosh K <ashut...@clogeny.com> Authored: Wed Nov 13 21:54:35 2013 +0530 Committer: Girish Shilamkar <gir...@clogeny.com> Committed: Wed Nov 13 21:56:20 2013 +0530 ---------------------------------------------------------------------- .../component/test_vpc_vm_life_cycle.py | 953 ++++++++++++++++++- tools/marvin/marvin/integration/lib/base.py | 8 + 2 files changed, 959 insertions(+), 2 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/cloudstack/blob/7bb7c08e/test/integration/component/test_vpc_vm_life_cycle.py ---------------------------------------------------------------------- diff --git a/test/integration/component/test_vpc_vm_life_cycle.py b/test/integration/component/test_vpc_vm_life_cycle.py index cc65eed..8e79f95 100644 --- a/test/integration/component/test_vpc_vm_life_cycle.py +++ b/test/integration/component/test_vpc_vm_life_cycle.py @@ -58,7 +58,7 @@ class Services: "cpunumber": 1, "cpuspeed": 100, "memory": 128, - "tags": "HOST_TAGS_HERE" + "hosttags": "host1" }, "service_offering_2": { "name": "Tiny Instance- tagged host 2", @@ -66,7 +66,7 @@ class Services: "cpunumber": 1, "cpuspeed": 100, "memory": 128, - "tags": "HOST_TAGS_HERE" + "hosttags": "host2" }, "network_offering": { "name": 'VPC Network offering', @@ -2717,3 +2717,952 @@ class TestVMLifeCycleStoppedVPCVR(cloudstackTestCase): listall=True ) return + +class TestVMLifeCycleDiffHosts(cloudstackTestCase): + + @classmethod + def setUpClass(cls): + try: + + cls.api_client = super( + TestVMLifeCycleDiffHosts, + cls + ).getClsTestClient().getApiClient() + cls.services = Services().services + # Get Zone, Domain and templates + cls.domain = get_domain(cls.api_client, cls.services) + cls.zone = get_zone(cls.api_client, cls.services) + cls.template = get_template( + cls.api_client, + cls.zone.id, + cls.services["ostype"] + ) + cls.services["virtual_machine"]["zoneid"] = cls.zone.id + cls.services["virtual_machine"]["template"] = cls.template.id + + hosts = list_hosts(cls.api_client) + + assert isinstance(hosts, list), "list_hosts should return a list response,\ + instead got %s" % hosts + + if len(hosts) < 3: + raise Exception("Minimum 3 hosts should be available to run this test suite") + + Host.update(cls.api_client, id=hosts[0].id, hosttags="host1") + + Host.update(cls.api_client, id=hosts[1].id, hosttags="host1") + + Host.update(cls.api_client, id=hosts[2].id, hosttags="host2") + + 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.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)] + ) + + cls.public_ip_static = PublicIPAddress.create( + cls.api_client, + accountid=cls.account.name, + zoneid=cls.zone.id, + domainid=cls.account.domainid, + networkid=cls.network_1.id, + vpcid=cls.vpc.id + ) + StaticNATRule.enable( + cls.api_client, + ipaddressid=cls.public_ip_static.ipaddress.id, + virtualmachineid=cls.vm_1.id, + networkid=cls.network_1.id + ) + + cls.public_ip_1 = PublicIPAddress.create( + cls.api_client, + accountid=cls.account.name, + zoneid=cls.zone.id, + domainid=cls.account.domainid, + networkid=cls.network_1.id, + vpcid=cls.vpc.id + ) + + cls.nat_rule = NATRule.create( + cls.api_client, + cls.vm_1, + cls.services["natrule"], + ipaddressid=cls.public_ip_1.ipaddress.id, + openfirewall=False, + networkid=cls.network_1.id, + vpcid=cls.vpc.id + ) + + cls.public_ip_2 = PublicIPAddress.create( + cls.api_client, + accountid=cls.account.name, + zoneid=cls.zone.id, + domainid=cls.account.domainid, + networkid=cls.network_1.id, + vpcid=cls.vpc.id + ) + + cls.lb_rule = LoadBalancerRule.create( + cls.api_client, + cls.services["lbrule"], + ipaddressid=cls.public_ip_2.ipaddress.id, + accountid=cls.account.name, + networkid=cls.network_1.id, + vpcid=cls.vpc.id, + domainid=cls.account.domainid + ) + cls.lb_rule.assign(cls.api_client, [cls.vm_1, cls.vm_2]) + + # Opening up the ports in VPC + cls.nwacl_nat = NetworkACL.create( + cls.api_client, + networkid=cls.network_1.id, + services=cls.services["natrule"], + traffictype='Ingress' + ) + + cls.nwacl_lb = NetworkACL.create( + cls.api_client, + networkid=cls.network_1.id, + services=cls.services["lbrule"], + traffictype='Ingress' + ) + + cls.nwacl_internet = NetworkACL.create( + cls.api_client, + networkid=cls.network_1.id, + services=cls.services["icmp_rule"], + traffictype='Egress' + ) + cls._cleanup = [ + cls.service_offering_1, + cls.service_offering_2, + cls.nw_off, + cls.nw_off_no_lb, + ] + + except Exception as e: + raise Exception("Warning: Exception during setup : %s" % e) + + return + + @classmethod + def tearDownClass(cls): + try: + 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) + + # Waiting for network cleanup to delete vpc offering + wait_for_cleanup(cls.api_client, ["network.gc.wait", + "network.gc.interval"]) + 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.cleanup = [] + return + + def tearDown(self): + try: + #Clean up, terminate the created network offerings + cleanup_resources(self.apiclient, self.cleanup) + wait_for_cleanup(self.apiclient, [ + "network.gc.interval", + "network.gc.wait"]) + + 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 + + def validate_vpc_offering(self, vpc_offering): + """Validates the VPC offering""" + + self.debug("Check if the VPC offering is created successfully?") + vpc_offs = VpcOffering.list( + self.apiclient, + id=vpc_offering.id + ) + self.assertEqual( + isinstance(vpc_offs, list), + True, + "List VPC offerings should return a valid list" + ) + self.assertEqual( + vpc_offering.name, + vpc_offs[0].name, + "Name of the VPC offering should match with listVPCOff data" + ) + self.debug( + "VPC offering is created successfully - %s" % + vpc_offering.name) + return + + def validate_vpc_network(self, network, state=None): + """Validates the VPC network""" + + self.debug("Check if the VPC network is created successfully?") + vpc_networks = VPC.list( + self.apiclient, + id=network.id + ) + self.assertEqual( + isinstance(vpc_networks, list), + True, + "List VPC network should return a valid list" + ) + self.assertEqual( + network.name, + vpc_networks[0].name, + "Name of the VPC network should match with listVPC data" + ) + if state: + self.assertEqual( + vpc_networks[0].state, + state, + "VPC state should be '%s'" % state + ) + self.debug("VPC network validated - %s" % network.name) + return + + def validate_network_rules(self): + """Validates if the network rules work properly or not?""" + for ip in [self.public_ip_1.ipaddress.ipaddress, self.public_ip_2.ipaddress.ipaddress, self.public_ip_static.ipaddress.ipaddress]: + try: + self.debug("Checking if we can SSH into VM_1 through %s?" % + (ip)) + ssh = self.vm_1.get_ssh_client( + ipaddress=ip, + reconnect=True) + + self.assertNotEqual(ssh, None, + "SSH client should be returned successfully") + + self.debug("SSH into VM is successfully") + + self.debug("Verifying if we can ping to outside world from VM?") + # Ping to outsite world + res = ssh.execute("ping -c 1 www.google.com") + # res = 64 bytes from maa03s17-in-f20.1e100.net (74.125.236.212): + # icmp_req=1 ttl=57 time=25.9 ms + # --- www.l.google.com ping statistics --- + # 1 packets transmitted, 1 received, 0% packet loss, time 0ms + # rtt min/avg/max/mdev = 25.970/25.970/25.970/0.000 ms + result = str(res) + self.assertEqual( + result.count("1 received"), + 1, + "Ping to outside world from VM should be successful" + ) + except Exception as e: + self.fail("Failed to SSH into VM - %s, %s" % + (ip, e)) + + return + + @attr(tags=["advanced","multihost", "intervlan"]) + def test_01_deploy_instance_in_network(self): + """ Test deploy an instance in VPC networks + """ + + # 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. + # Steps: + # 1. Deploy vm1 and vm2 in network1 and vm3 and vm4 in network2 using + # the default CentOS 6.2 Template + + self.validate_vm_deployment() + self.debug("Check if deployed VMs are in running state?") + vms = VirtualMachine.list( + self.apiclient, + account=self.account.name, + domainid=self.account.domainid, + listall=True + ) + self.assertEqual( + isinstance(vms, list), + True, + "List VMs should return a valid response" + ) + for vm in vms: + self.debug("VM name: %s, VM state: %s" % (vm.name, vm.state)) + self.assertEqual( + vm.state, + "Running", + "Vm state should be running for each VM deployed" + ) + return + + @attr(tags=["advanced","multihost", "intervlan"]) + def test_02_stop_instance_in_network(self): + """ Test stop an instance in VPC networks + """ + + # Validate the following + # 1. Stop the virtual machines. + # 2. Rules should be still configured on virtual router. + + self.debug("Stopping the virtual machines in account: %s" % + self.account.name) + try: + self.vm_1.stop(self.apiclient) + + list_vm_response = list_virtual_machines( + self.apiclient, + id=self.vm_1.id + ) + + vm_response = list_vm_response[0] + + self.assertEqual( + vm_response.state, + 'Stopped', + "VM state should be stopped" + ) + + self.vm_2.stop(self.apiclient) + + list_vm_response = list_virtual_machines( + self.apiclient, + id=self.vm_2.id + ) + + vm_response = list_vm_response[0] + + self.assertEqual( + vm_response.state, + 'Stopped', + "VM state should be stopped" + ) + + except Exception as e: + self.fail("Failed to stop the virtual instances, %s" % e) + + # Check if the network rules still exists after Vm stop + self.debug("Checking if NAT rules ") + nat_rules = NATRule.list( + self.apiclient, + id=self.nat_rule.id, + listall=True + ) + self.assertEqual( + isinstance(nat_rules, list), + True, + "List NAT rules shall return a valid list" + ) + + lb_rules = LoadBalancerRule.list( + self.apiclient, + id=self.lb_rule.id, + listall=True + ) + self.assertEqual( + isinstance(lb_rules, list), + True, + "List LB rules shall return a valid list" + ) + return + + @attr(tags=["advanced","multihost", "intervlan"]) + def test_03_start_instance_in_network(self): + """ Test start an instance in VPC networks + """ + + # Validate the following + # 1. Start the virtual machines. + # 2. Vm should be started successfully. + # 3. Make sure that all the PF,LB and Static NAT rules on this VM + # works as expected. + # 3. Make sure that we are able to access google.com from this user Vm + + self.debug("Starting the virtual machines in account: %s" % + self.account.name) + try: + self.vm_1.start(self.apiclient) + + list_vm_response = list_virtual_machines( + self.apiclient, + id=self.vm_1.id + ) + + vm_response = list_vm_response[0] + + self.assertEqual( + vm_response.state, + 'Running', + "VM state should be running" + ) + + self.vm_2.start(self.apiclient) + + list_vm_response = list_virtual_machines( + self.apiclient, + id=self.vm_2.id + ) + + vm_response = list_vm_response[0] + + self.assertEqual( + vm_response.state, + 'Running', + "VM state should be running" + ) + + except Exception as e: + self.fail("Failed to start the virtual instances, %s" % e) + self.debug("Validating if the network rules work properly or not?") + self.validate_network_rules() + return + + @attr(tags=["advanced","multihost", "intervlan"]) + def test_04_reboot_instance_in_network(self): + """ Test reboot an instance in VPC networks + """ + + # Validate the following + # 1. Reboot the virtual machines. + # 2. Vm should be started successfully. + # 3. Make sure that all the PF,LB and Static NAT rules on this VM + # works as expected. + # 3. Make sure that we are able to access google.com from this user Vm + + self.debug("Validating if the network rules work properly or not?") + self.validate_network_rules() + + self.debug("Starting the virtual machines in account: %s" % + self.account.name) + try: + self.vm_1.reboot(self.apiclient) + self.vm_2.reboot(self.apiclient) + except Exception as e: + self.fail("Failed to reboot the virtual instances, %s" % e) + + self.debug("Validating if the network rules work properly or not?") + self.validate_network_rules() + return + + @attr(tags=["advanced","multihost", "intervlan"]) + def test_05_destroy_instance_in_network(self): + """ Test destroy an instance in VPC networks + """ + + # Validate the following + # 1. Destory the virtual machines. + # 2. Rules should be still configured on virtual router. + # 3. Recover the virtual machines. + # 4. Vm should be in stopped state. State both the instances + # 5. Make sure that all the PF,LB and Static NAT rules on this VM + # works as expected. + # 6. Make sure that we are able to access google.com from this user Vm + + self.debug("Validating if the network rules work properly or not?") + self.validate_network_rules() + + self.debug("Destroying the virtual machines in account: %s" % + self.account.name) + try: + self.vm_1.delete(self.apiclient) + + list_vm_response = list_virtual_machines( + self.apiclient, + id=self.vm_1.id + ) + + vm_response = list_vm_response[0] + + self.assertEqual( + vm_response.state, + 'Destroyed', + "VM state should be destroyed" + ) + + self.vm_2.delete(self.apiclient) + + list_vm_response = list_virtual_machines( + self.apiclient, + id=self.vm_2.id + ) + + vm_response = list_vm_response[0] + + self.assertEqual( + vm_response.state, + 'Destroyed', + "VM state should be destroyed" + ) + + except Exception as e: + self.fail("Failed to stop the virtual instances, %s" % e) + + # Check if the network rules still exists after Vm stop + self.debug("Checking if NAT rules ") + nat_rules = NATRule.list( + self.apiclient, + id=self.nat_rule.id, + listall=True + ) + self.assertEqual( + isinstance(nat_rules, list), + True, + "List NAT rules shall return a valid list" + ) + + lb_rules = LoadBalancerRule.list( + self.apiclient, + id=self.lb_rule.id, + listall=True + ) + self.assertEqual( + isinstance(lb_rules, list), + True, + "List LB rules shall return a valid list" + ) + + self.debug("Recovering the expunged virtual machines in account: %s" % + self.account.name) + try: + self.vm_1.recover(self.apiclient) + + list_vm_response = list_virtual_machines( + self.apiclient, + id=self.vm_1.id + ) + + vm_response = list_vm_response[0] + + self.assertEqual( + vm_response.state, + 'Stopped', + "VM state should be stopped" + ) + + self.vm_2.recover(self.apiclient) + + list_vm_response = list_virtual_machines( + self.apiclient, + id=self.vm_2.id + ) + + vm_response = list_vm_response[0] + + self.assertEqual( + vm_response.state, + 'Stopped', + "VM state should be stopped" + ) + except Exception as e: + self.fail("Failed to recover the virtual instances, %s" % e) + + self.debug("Starting the two instances..") + try: + self.vm_1.start(self.apiclient) + + list_vm_response = list_virtual_machines( + self.apiclient, + id=self.vm_1.id + ) + + vm_response = list_vm_response[0] + + self.assertEqual( + vm_response.state, + 'Running', + "VM state should be running" + ) + + self.vm_2.start(self.apiclient) + + list_vm_response = list_virtual_machines( + self.apiclient, + id=self.vm_2.id + ) + + vm_response = list_vm_response[0] + + self.assertEqual( + vm_response.state, + 'Running', + "VM state should be running" + ) + except Exception as e: + self.fail("Failed to start the instances, %s" % e) + + # Wait until vms are up + time.sleep(120) + self.debug("Validating if the network rules work properly or not?") + self.validate_network_rules() + + return + + @attr(tags=["advanced","multihost", "intervlan"]) + def test_06_migrate_instance_in_network(self): + """ Test migrate an instance in VPC networks + """ + + # Validate the following + # 1. Migrate the virtual machines to other hosts + # 2. Vm should be in stopped state. State both the instances + # 3. Make sure that all the PF,LB and Static NAT rules on this VM + # works as expected. + # 3. Make sure that we are able to access google.com from this user Vm + + self.debug("Checking if the host is available for migration?") + hosts = Host.listForMigration( + self.apiclient, + virtualmachineid=self.vm_1.id, + ) + self.debug("Hosts vm can be migrated to are : %s" %(hosts)) + self.assertEqual( + isinstance(hosts, list), + True, + "List hosts should return a valid list" + ) + # Remove the host of current VM from the hosts list + hosts[:] = [host for host in hosts if host.id != self.vm_1.hostid] + if len(hosts) <= 0: + self.skipTest( + "No host available for migration. Test requires atleast 2 hosts tagged with host1") + + host = hosts[0] + + self.debug("Validating if the network rules work properly or not?") + self.validate_network_rules() + + self.debug("Migrating VM-ID: %s to Host: %s" % ( + self.vm_1.id, + host.id + )) + + try: + self.vm_1.migrate(self.apiclient, hostid=host.id) + except Exception as e: + self.fail("Failed to migrate instance, %s" % e) + + self.debug("Validating if the network rules work properly or not?") + self.validate_network_rules() + return + + @attr(tags=["advanced","multihost", "intervlan"]) + def test_07_user_data(self): + """ Test user data in virtual machines + """ + + # 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 a vm in network1 and a vm in network2 using userdata + # Steps + # 1.Query for the user data for both the user vms from both networks + # User should be able to query the user data for the vms belonging to + # both the networks from the VR + self.debug("Checking if we can SSH into VM_1 through %s" % + (self.public_ip_2.ipaddress.ipaddress)) + try: + ssh = self.vm_1.get_ssh_client( + ipaddress=self.public_ip_2.ipaddress.ipaddress, + reconnect=True) + + self.assertNotEqual(ssh, None, + "get_ssh_client should return ssh handle") + + self.debug("SSH into VM is successfully") + except Exception as e: + self.fail("Failed to SSH into instance: %s" % e) + + self.debug("check the userdata with that of present in router") + try: + cmds = [ + "wget http://%s/latest/user-data"; % self.network_1.gateway, + "cat user-data", + ] + for c in cmds: + result = ssh.execute(c) + self.debug("%s: %s" % (c, result)) + except Exception as e: + self.fail("Failed to SSH in Virtual machine: %s" % e) + + res = str(result) + self.assertEqual( + res.count( + self.services["virtual_machine"]["userdata"]), + 1, + "Verify user data from router" + ) + return + + @attr(tags=["advanced","multihost", "intervlan"]) + def test_08_meta_data(self): + """ Test meta data in virtual machines + """ + + # 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 a vm in network1 and a vm in network2 using userdata + # Steps + # 1.Query for the meta data for both the user vms from both networks + # User should be able to query the user data for the vms belonging to + # both the networks from the VR + self.debug("Checking if we can SSH into VM_1 through %s" % + (self.public_ip_2.ipaddress.ipaddress)) + try: + ssh = self.vm_1.get_ssh_client( + ipaddress=self.public_ip_2.ipaddress.ipaddress, + reconnect=True) + + self.assertNotEqual(ssh, None, + "get_ssh_client should return ssh handle") + + self.debug("SSH into VM is successfully") + except Exception as e: + self.fail("Failed to SSH into instance: %s" % e) + + self.debug("check the metadata with that of present in router") + try: + cmds = [ + "wget http://%s/latest/vm-id"; % self.network_1.gateway, + "cat vm-id", + ] + for c in cmds: + result = ssh.execute(c) + self.debug("%s: %s" % (c, result)) + except Exception as e: + self.fail("Failed to SSH in Virtual machine: %s" % e) + + res = str(result) + self.assertNotEqual( + res, + None, + "Meta data should be returned from router" + ) + return + + @attr(tags=["advanced","multihost", "intervlan"]) + def test_09_expunge_instance_in_network(self): + """ Test expunge an instance in VPC networks + """ + + # Validate the following + # 1. Recover the virtual machines. + # 2. Vm should be in stopped state. State both the instances + # 3. Make sure that all the PF,LB and Static NAT rules on this VM + # works as expected. + # 3. Make sure that we are able to access google.com from this user Vm + + self.debug("Validating if the network rules work properly or not?") + self.validate_network_rules() + + self.debug("Delete virtual machines in account: %s" % + self.account.name) + try: + self.vm_1.delete(self.apiclient) + + list_vm_response = list_virtual_machines( + self.apiclient, + id=self.vm_1.id + ) + + vm_response = list_vm_response[0] + + self.assertEqual( + vm_response.state, + 'Destroyed', + "VM state should be destroyed" + ) + + self.vm_2.delete(self.apiclient) + + list_vm_response = list_virtual_machines( + self.apiclient, + id=self.vm_2.id + ) + + vm_response = list_vm_response[0] + + self.assertEqual( + vm_response.state, + 'Destroyed', + "VM state should be destroyed" + ) + + self.vm_3.delete(self.apiclient) + + list_vm_response = list_virtual_machines( + self.apiclient, + id=self.vm_3.id + ) + + vm_response = list_vm_response[0] + + self.assertEqual( + vm_response.state, + 'Destroyed', + "VM state should be destroyed" + ) + except Exception as e: + self.fail("Failed to destroy the virtual instances, %s" % e) + + self.debug( + "Waiting for expunge interval to cleanup the network and VMs") + + wait_for_cleanup( + self.apiclient, + ["expunge.interval", "expunge.delay"] + ) + + # Check if the network rules still exists after Vm stop + self.debug("Checking if NAT rules existed") + with self.assertRaises(Exception): + NATRule.list( + self.apiclient, + id=self.nat_rule.id, + listall=True + ) + + LoadBalancerRule.list( + self.apiclient, + id=self.lb_rule.id, + listall=True + ) + return http://git-wip-us.apache.org/repos/asf/cloudstack/blob/7bb7c08e/tools/marvin/marvin/integration/lib/base.py ---------------------------------------------------------------------- diff --git a/tools/marvin/marvin/integration/lib/base.py b/tools/marvin/marvin/integration/lib/base.py index 10c636c..a3a5f58 100755 --- a/tools/marvin/marvin/integration/lib/base.py +++ b/tools/marvin/marvin/integration/lib/base.py @@ -1860,6 +1860,14 @@ class Host: [setattr(cmd, k, v) for k, v in kwargs.items()] return(apiclient.findHostsForMigration(cmd)) + @classmethod + def update(cls, apiclient, **kwargs): + """Update host information""" + + cmd = updateHost.updateHostCmd() + [setattr(cmd, k, v) for k, v in kwargs.items()] + return(apiclient.updateHost(cmd)) + class StoragePool: """Manage Storage pools (Primary Storage)"""
