| # 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. | |
| import logging | |
| import time | |
| import requests | |
| from nose.plugins.attrib import attr | |
| from marvin.cloudstackTestCase import cloudstackTestCase | |
| from marvin.lib.base import (Network, NetworkOffering, Account, VirtualMachine, ServiceOffering, | |
| NATRule, PublicIPAddress, EgressFireWallRule, Host, | |
| FireWallRule, LoadBalancerRule, LogicalRouter, ApplicationPolicySet, | |
| FirewallPolicy, FirewallRule, TungstenTag, ServiceGroup, | |
| NetworkPolicy, PolicyRule) | |
| from marvin.cloudstackAPI import migrateVirtualMachine | |
| from marvin.lib.utils import (is_server_ssh_ready, get_host_credentials, execute_command_in_host) | |
| from marvin.lib.common import get_zone, get_template | |
| from marvin.lib.decoratorGenerators import skipTestIf | |
| from .common import is_object_created, is_object_deleted, get_list_system_vm, cleanup_resources, not_tungsten_fabric_zone | |
| class Services: | |
| """Test Tungsten Plugin | |
| """ | |
| def __init__(self): | |
| self.services = { | |
| "network_offering": { | |
| "name": "TungstenNetworkOffering", | |
| "displaytext": "TungstenNetworkOffering", | |
| "guestiptype": "Isolated", | |
| "traffictype": "GUEST", | |
| "supportedservices": [ | |
| "Dhcp", | |
| "Dns", | |
| "Lb", | |
| "UserData", | |
| "SourceNat", | |
| "StaticNat", | |
| "PortForwarding", | |
| "Connectivity", | |
| "Firewall" | |
| ], | |
| "serviceProviderList": { | |
| "Dhcp": "Tungsten", | |
| "Dns": "Tungsten", | |
| "Lb": "Tungsten", | |
| "UserData": "ConfigDrive", | |
| "SourceNat": "Tungsten", | |
| "StaticNat": "Tungsten", | |
| "PortForwarding": "Tungsten", | |
| "Connectivity": "Tungsten", | |
| "Firewall": "Tungsten" | |
| }, | |
| "useTungsten": "on" | |
| }, | |
| "networks": { | |
| "network1": { | |
| "name": "TF-Network1", | |
| "displaytext": "TF-Network1", | |
| "gateway": "10.1.1.1", | |
| "netmask": "255.255.255.0", | |
| "startip": "10.1.1.100", | |
| "endip": "10.1.1.200" | |
| }, | |
| "network2": { | |
| "name": "TF-Network2", | |
| "displaytext": "TF-Network2", | |
| "gateway": "10.1.2.1", | |
| "netmask": "255.255.255.0", | |
| "startip": "10.1.2.100", | |
| "endip": "10.1.2.200" | |
| } | |
| }, | |
| "ostype": "112", | |
| "account": { | |
| "email": "test@test.com", | |
| "firstname": "Test", | |
| "lastname": "User", | |
| "username": "test", | |
| "password": "password", | |
| }, | |
| "virtual_machines": { | |
| "vm1": { | |
| "name": "vm1", | |
| "displayname": "vm1", | |
| "username": "root", | |
| "password": "password", | |
| "ssh_port": 22, | |
| "hypervisor": 'KVM', | |
| "privateport": 22, | |
| "publicport": 22, | |
| "protocol": 'TCP' | |
| }, | |
| "vm2": { | |
| "name": "vm2", | |
| "displayname": "vm2", | |
| "username": "root", | |
| "password": "password", | |
| "ssh_port": 22, | |
| "hypervisor": 'KVM', | |
| "privateport": 22, | |
| "publicport": 22, | |
| "protocol": 'TCP' | |
| }, | |
| "vm3": { | |
| "name": "vm3", | |
| "displayname": "vm3", | |
| "username": "root", | |
| "password": "password", | |
| "ssh_port": 22, | |
| "hypervisor": 'KVM', | |
| "privateport": 22, | |
| "publicport": 22, | |
| "protocol": 'TCP' | |
| } | |
| }, | |
| "fw_rule": { | |
| "startport": 80, | |
| "endport": 80, | |
| "cidr": '0.0.0.0/0', | |
| "protocol": "TCP" | |
| }, | |
| "nat_rule": { | |
| "privateport": 80, | |
| "publicport": 80, | |
| "protocol": 'TCP' | |
| }, | |
| "lbrule": { | |
| "name": "SSH", | |
| "alg": "roundrobin", | |
| "privateport": 80, | |
| "publicport": 80, | |
| "protocol": 'TCP' | |
| }, | |
| "logicalrouter": { | |
| "name": "TFLogicalRouter" | |
| }, | |
| "applicationpolicysets": { | |
| "aps1": { | |
| "name": "aps1" | |
| } | |
| }, | |
| "firewallpolicys": { | |
| "frontend": { | |
| "name": "frontend" | |
| }, | |
| "internet": { | |
| "name": "internet" | |
| }, | |
| "host": { | |
| "name": "host" | |
| } | |
| }, | |
| "firewallrules": { | |
| "frontend": { | |
| "name": "frontend", | |
| "action": "pass", | |
| "direction": "oneway" | |
| }, | |
| "internet": { | |
| "name": "internet", | |
| "action": "pass", | |
| "direction": "oneway" | |
| }, | |
| "host": { | |
| "name": "host", | |
| "action": "pass", | |
| "direction": "oneway" | |
| } | |
| }, | |
| "servicegroups": { | |
| "any": { | |
| "name": "any", | |
| "protocol": "any", | |
| "startport": -1, | |
| "endport": -1 | |
| } | |
| }, | |
| "network_policy": { | |
| "policy1": { | |
| "name": "policy1", | |
| "rules": { | |
| "rule1": { | |
| "action": "pass", | |
| "direction": "twoway", | |
| "protocol": "icmp", | |
| "srcnetwork": "any", | |
| "srcipprefix": "0.0.0.0", | |
| "srcipprefixlend": 0, | |
| "srcstartport": -1, | |
| "srcendport": -1, | |
| "destnetwork": "any", | |
| "destipprefix": "0.0.0.0", | |
| "destipprefixlen": 0, | |
| "deststartport": -1, | |
| "destendport": -1 | |
| } | |
| } | |
| } | |
| }, | |
| "network_route_table": { | |
| "route_table_1": { | |
| "name": "Network Route Table 1", | |
| "prefix": "10.1.2.0/24", | |
| "nexthoptype": "ip-address", | |
| "communities": "" | |
| }, | |
| "route_table_2": { | |
| "name": "Network Route Table 2", | |
| "prefix": "10.1.1.0/24", | |
| "nexthoptype": "ip-address", | |
| "communities": "" | |
| } | |
| }, | |
| "interface_route_table": { | |
| "route_table_1": { | |
| "name": "Interface Route Table 1", | |
| "prefix": "10.1.2.0/24", | |
| "communities": "" | |
| }, | |
| "route_table_2": { | |
| "name": "Interface Route Table 2", | |
| "prefix": "10.1.1.0/24", | |
| "communities": "" | |
| } | |
| }, | |
| "routing_policy": { | |
| "routing_policy_1": { | |
| "name": "Routing Policy 1", | |
| "matchall": "true", | |
| "protocollist": [""], | |
| "prefixlist": [ | |
| "10.1.2.0/24&exact" | |
| ], | |
| "termlist": [ | |
| "reject&action& " | |
| ], | |
| "communities": [""] | |
| } | |
| } | |
| } | |
| class TestIsolatedZone(cloudstackTestCase): | |
| @classmethod | |
| def setUpClass(cls): | |
| cls.apiclient = cls.clstestclient.getApiClient() | |
| cls.dbclient = cls.clstestclient.getDbConnection() | |
| cls.services = Services().services | |
| cls.testdata = cls.clstestclient.getParsedTestDataConfig() | |
| cls.zone = get_zone(cls.apiclient, cls.clstestclient.getZoneForTests()) | |
| cls.hypervisor = cls.clstestclient.getHypervisorInfo() | |
| cls.tfgw = cls.getClsConfig()["zones"][0]["tungstenprovider"]["gateway"] | |
| cls.config = cls.getClsConfig() | |
| cls.template = get_template(cls.apiclient, cls.zone.id) | |
| cls.hosts = Host.list(cls.apiclient, zoneid=cls.zone.id, type="routing") | |
| for host in cls.hosts: | |
| Host.reconnect(cls.apiclient, id=host.id) | |
| cls.not_tungsten_fabric_zone = not_tungsten_fabric_zone(cls.apiclient, cls.zone.id) | |
| cls.is_single_host = len(cls.hosts) < 2 | |
| cls.can_not_migrate = cls.not_tungsten_fabric_zone or cls.is_single_host | |
| cls._cleanup = [] | |
| cls.logger = logging.getLogger("TestIsolatedZone") | |
| cls.stream_handler = logging.StreamHandler() | |
| cls.logger.setLevel(logging.DEBUG) | |
| cls.logger.addHandler(cls.stream_handler) | |
| @classmethod | |
| def tearDownClass(self): | |
| try: | |
| cleanup_resources(self.apiclient, self.zone.id, self._cleanup) | |
| except Exception as e: | |
| raise Exception("Warning: Exception during cleanup : %s" % e) | |
| return | |
| def setUp(self): | |
| self.account = Account.create(self.apiclient, self.services["account"], admin=True) | |
| self.service_offering = ServiceOffering.create(self.apiclient, self.testdata["service_offering"]) | |
| self.cleanup = [self.account, self.service_offering] | |
| return | |
| def tearDown(self): | |
| try: | |
| cleanup_resources(self.apiclient, self.zone.id, reversed(self.cleanup)) | |
| except Exception as e: | |
| raise Exception("Warning: Exception during cleanup : %s" % e) | |
| return | |
| @skipTestIf("not_tungsten_fabric_zone") | |
| @attr(tags=["tungstenfabric"], required_hardware="false") | |
| def test_01_configuration(self): | |
| # check if public network was created in tungsten fabric when deployed zone with setup/dev/advancedtf.cfg | |
| list_public_network = Network.list(self.apiclient, zoneid=self.zone.id, issystem=True, | |
| traffictype="Public") | |
| self.assertEqual(is_object_created(self.apiclient, self.zone.id, "virtual-network", | |
| list_public_network[0].id), True, | |
| "Check if public network was created in tungsten") | |
| # check if management network was created in tungsten fabric when deployed zone with setup/dev/advancedtf.cfg | |
| list_management_network = Network.list(self.apiclient, zoneid=self.zone.id, issystem=True, | |
| traffictype="Management") | |
| self.assertEqual(is_object_created(self.apiclient, self.zone.id, "virtual-network", | |
| list_management_network[0].id), True, | |
| "Check if management network was created in tungsten") | |
| # check if ssvm and proxyvm was created in tungsten fabric when deployed zone with setup/dev/advancedtf.cfg | |
| list_system_vm = get_list_system_vm(self.apiclient, self.zone.id) | |
| for system_vm in list_system_vm: | |
| # check if system vm was created in tungsten fabric | |
| self.assertEqual( | |
| is_object_created(self.apiclient, self.zone.id, "virtual-machine", system_vm.id), | |
| True, "Check if system vm was created in tungsten fabric") | |
| # check if tungsten fabric virtual gateway was created | |
| username, password = get_host_credentials(self.config, self.tfgw) | |
| ssh = is_server_ssh_ready(self.tfgw, 22, username, password) | |
| vgw = ssh.execute("vif --list | grep vgw") | |
| self.assertEqual( | |
| str(vgw).count("vgw"), 1, "Check if vgw was created in host" | |
| ) | |
| return | |
| @skipTestIf("not_tungsten_fabric_zone") | |
| @attr(tags=["tungstenfabric"], required_hardware="false") | |
| def test_01_connectivity(self): | |
| # test create network offering | |
| network_offering = NetworkOffering.create(self.apiclient, self.services["network_offering"]) | |
| network_offering.update(self.apiclient, state='Enabled') | |
| self.cleanup.append(network_offering) | |
| # check if network offering was created | |
| self.logger.info("network offering id is %s" % network_offering.id) | |
| list_network_offering_response = NetworkOffering.list(self.apiclient, | |
| id=network_offering.id) | |
| self.assertEqual(isinstance(list_network_offering_response, list), True, | |
| "Check for a valid list network response") | |
| # create network | |
| network = Network.create( | |
| self.apiclient, | |
| self.services["networks"]["network1"], | |
| networkofferingid=network_offering.id, | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid | |
| ) | |
| # check if network was created in cloudstack | |
| self.logger.info("network id is %s" % network.id) | |
| list_network_response = Network.list(self.apiclient, id=network.id, listall=True) | |
| self.assertEqual(isinstance(list_network_response, list), True, | |
| "Check for a valid list network response") | |
| # create virtual machine 1 | |
| vm1 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm1"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced' | |
| ) | |
| # create virtual machine 2 | |
| vm2 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm2"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced' | |
| ) | |
| # check if vm 1 was created in cloudstack | |
| self.logger.info("vm id is %s" % vm1.id) | |
| list_vm_response = VirtualMachine.list(self.apiclient, id=vm1.id, listall=True) | |
| self.assertEqual(isinstance(list_vm_response, list), True, | |
| "Check for a valid list vm response") | |
| # check if vm 2 was created in cloudstack | |
| self.logger.info("vm id is %s" % vm2.id) | |
| list_vm_response = VirtualMachine.list(self.apiclient, id=vm2.id, listall=True) | |
| self.assertEqual(isinstance(list_vm_response, list), True, | |
| "Check for a valid list vm response") | |
| # wait for vm start | |
| time.sleep(30) | |
| # tungsten fabric network was only created when network was implemented | |
| # check if network was created in tungsten fabric | |
| self.assertEqual( | |
| is_object_created(self.apiclient, self.zone.id, "virtual-network", network.id), True, | |
| "Check if network was created in tungsten") | |
| # check if vm 1 was created in tungsten fabric | |
| self.assertEqual(is_object_created(self.apiclient, self.zone.id, "virtual-machine", vm1.id), | |
| True, "Check if vm1 was created in tungsten") | |
| # check if vm 2 was created in tungsten fabric | |
| self.assertEqual(is_object_created(self.apiclient, self.zone.id, "virtual-machine", vm2.id), | |
| True, "Check if vm1 was created in tungsten") | |
| # check if nic 1 was created in tungsten fabric | |
| self.assertEqual( | |
| is_object_created(self.apiclient, self.zone.id, "virtual-machine-interface", vm1.nic[0].id), | |
| True, "Check if nic 1 was created in tungsten") | |
| # check if nic 2 was created in tungsten fabric | |
| self.assertEqual( | |
| is_object_created(self.apiclient, self.zone.id, "virtual-machine-interface", vm2.nic[0].id), | |
| True, "Check if nic 2 was created in tungsten") | |
| # check vm1 vif interface was created in host | |
| host1 = Host.list(self.apiclient, id=vm1.hostid) | |
| username, password = get_host_credentials(self.config, host1[0].ipaddress) | |
| tap1 = "tap" + vm1.nic[0].macaddress.replace(":", "") | |
| cmd1 = "vif --list | grep %s" % tap1 | |
| vif1 = execute_command_in_host(host1[0].ipaddress, 22, username, password, cmd1) | |
| self.assertEqual( | |
| str(vif1).count(tap1), 1, "Check if vm1 tap interface was created in host" | |
| ) | |
| # check vm2 vif interface was created in host | |
| host2 = Host.list(self.apiclient, id=vm2.hostid) | |
| username, password = get_host_credentials(self.config, host2[0].ipaddress) | |
| tap2 = "tap" + vm2.nic[0].macaddress.replace(":", "") | |
| cmd2 = "vif --list | grep %s" % tap2 | |
| vif2 = execute_command_in_host(host2[0].ipaddress, 22, username, password, cmd2) | |
| self.assertEqual( | |
| str(vif2).count(tap2), 1, "Check if vm2 tap interface was created in host" | |
| ) | |
| # ssh vm 1 and ping vm2 | |
| ssh1 = vm1.get_ssh_client() | |
| res_1 = ssh1.execute("ping -c1 %s" % vm2.ipaddress) | |
| # ssh vm 2 and ping vm1 | |
| ssh2 = vm2.get_ssh_client() | |
| res_2 = ssh2.execute("ping -c1 %s" % vm1.ipaddress) | |
| self.assertEqual( | |
| str(res_1).count("1 received"), | |
| 1, | |
| "Ping vm_2 from vm_1 should be successful" | |
| ) | |
| self.assertEqual( | |
| str(res_2).count("1 received"), | |
| 1, | |
| "Ping vm_1 from vm_2 should be successful" | |
| ) | |
| # delete vm 1 | |
| try: | |
| vm1.delete(self.apiclient, expunge=True) | |
| except Exception as e: | |
| raise Exception("Warning: Exception in expunging vms: %s" % e) | |
| # delete vm 2 | |
| try: | |
| vm2.delete(self.apiclient, expunge=True) | |
| except Exception as e: | |
| raise Exception("Warning: Exception in expunging vms: %s" % e) | |
| # check if nic 1 was deleted in tungsten fabric | |
| self.assertEqual( | |
| is_object_deleted(self.apiclient, self.zone.id, "virtual-machine-interface", vm1.nic[0].id), | |
| True, "Check if nic 1 was deleted in tungsten") | |
| # check if nic 2 was deleted in tungsten fabric | |
| self.assertEqual( | |
| is_object_deleted(self.apiclient, self.zone.id, "virtual-machine-interface", vm2.nic[0].id), | |
| True, "Check if nic 2 was deleted in tungsten") | |
| # check if vm 1 was deleted in tungsten fabric | |
| self.assertEqual( | |
| is_object_deleted(self.apiclient, self.zone.id, "virtual-machine", vm1.id), | |
| True, "Check if vm was deleted in tungsten") | |
| # check if vm 2 was deleted in tungsten fabric | |
| self.assertEqual( | |
| is_object_deleted(self.apiclient, self.zone.id, "virtual-machine", vm2.id), | |
| True, "Check if vm was deleted in tungsten") | |
| network.delete(self.apiclient) | |
| # check if network was deleted in tungsten fabric | |
| self.assertEqual( | |
| is_object_deleted(self.apiclient, self.zone.id, "virtual-network", network.id), | |
| True, "Check if network was deleted in tungsten") | |
| return | |
| @skipTestIf("not_tungsten_fabric_zone") | |
| @attr(tags=["tungstenfabric"], required_hardware="false") | |
| def test_01_sourcenat(self): | |
| # create network offering | |
| network_offering = NetworkOffering.create(self.apiclient, self.services["network_offering"]) | |
| network_offering.update(self.apiclient, state='Enabled') | |
| self.cleanup.append(network_offering) | |
| # create network | |
| network = Network.create( | |
| self.apiclient, | |
| self.services["networks"]["network1"], | |
| networkofferingid=network_offering.id, | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid | |
| ) | |
| self.cleanup.append(network) | |
| # create virtual machine | |
| vm = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm1"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced' | |
| ) | |
| self.cleanup.append(vm) | |
| # open firewall rule | |
| EgressFireWallRule.create( | |
| apiclient=self.apiclient, | |
| networkid=network.id, | |
| protocol='All', | |
| cidrlist='0.0.0.0/0' | |
| ) | |
| # wait for vm start | |
| # time.sleep(30) | |
| # ssh vm, ping google.com and verified response package | |
| ssh = vm.get_ssh_client() | |
| res = ssh.execute("ping -c1 google.com") | |
| self.assertEqual( | |
| str(res).count("1 received"), | |
| 1, | |
| "Ping google.com from vm should be successful" | |
| ) | |
| return | |
| @skipTestIf("not_tungsten_fabric_zone") | |
| @attr(tags=["tungstenfabric"], required_hardware="false") | |
| def test_01_staticnat(self): | |
| # create network offering | |
| network_offering = NetworkOffering.create(self.apiclient, self.services["network_offering"]) | |
| network_offering.update(self.apiclient, state='Enabled') | |
| self.cleanup.append(network_offering) | |
| # create network | |
| network = Network.create( | |
| self.apiclient, | |
| self.services["networks"]["network1"], | |
| networkofferingid=network_offering.id, | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid | |
| ) | |
| self.cleanup.append(network) | |
| # create virtual machine | |
| vm = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm1"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced' | |
| ) | |
| self.cleanup.append(vm) | |
| # wait for vm start | |
| time.sleep(30) | |
| public_ip = PublicIPAddress.create( | |
| apiclient=self.apiclient, | |
| accountid=self.account.name, | |
| zoneid=self.zone.id, | |
| domainid=self.account.domainid, | |
| services=self.services, | |
| networkid=network.id | |
| ) | |
| FireWallRule.create( | |
| apiclient=self.apiclient, | |
| ipaddressid=public_ip.ipaddress.id, | |
| protocol='TCP', | |
| cidrlist=['0.0.0.0/0'], | |
| startport=80, | |
| endport=80 | |
| ) | |
| NATRule.create( | |
| apiclient=self.apiclient, | |
| virtual_machine=vm, | |
| services=self.services["nat_rule"], | |
| ipaddressid=public_ip.ipaddress.id | |
| ) | |
| # ssh vm, start httpd, clear iptables | |
| ssh = vm.get_ssh_client() | |
| ssh.execute("service httpd start") | |
| ssh.execute("iptables -F") | |
| ssh.execute("echo test > /var/www/html/test.html") | |
| headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36'} | |
| r = requests.get("http://%s/test.html" % public_ip.ipaddress.ipaddress, headers=headers) | |
| self.assertEqual(r.status_code, 200, "Static nat was created and applied to vm") | |
| return | |
| @skipTestIf("not_tungsten_fabric_zone") | |
| @attr(tags=["tungstenfabric"], required_hardware="false") | |
| def test_01_loadbalancing(self): | |
| # create network offering | |
| network_offering = NetworkOffering.create(self.apiclient, self.services["network_offering"]) | |
| network_offering.update(self.apiclient, state='Enabled') | |
| self.cleanup.append(network_offering) | |
| # create network | |
| network = Network.create( | |
| self.apiclient, | |
| self.services["networks"]["network1"], | |
| networkofferingid=network_offering.id, | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid | |
| ) | |
| self.cleanup.append(network) | |
| # create virtual machine 1 | |
| vm1 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm1"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced' | |
| ) | |
| self.cleanup.append(vm1) | |
| # create virtual machine 2 | |
| vm2 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm2"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced' | |
| ) | |
| self.cleanup.append(vm2) | |
| public_ip = PublicIPAddress.create( | |
| apiclient=self.apiclient, | |
| accountid=self.account.name, | |
| zoneid=self.zone.id, | |
| domainid=self.account.domainid, | |
| services=self.services, | |
| networkid=network.id | |
| ) | |
| # open firewall rule | |
| EgressFireWallRule.create( | |
| apiclient=self.apiclient, | |
| networkid=network.id, | |
| protocol='All', | |
| cidrlist='0.0.0.0/0' | |
| ) | |
| firewall_rule = FireWallRule.create( | |
| apiclient=self.apiclient, | |
| ipaddressid=public_ip.ipaddress.id, | |
| protocol='TCP', | |
| cidrlist=['0.0.0.0/0'], | |
| startport=80, | |
| endport=80 | |
| ) | |
| self.cleanup.append(firewall_rule) | |
| lb_rule = LoadBalancerRule.create( | |
| self.apiclient, | |
| self.services["lbrule"], | |
| ipaddressid=public_ip.ipaddress.id, | |
| accountid=self.account.name | |
| ) | |
| self.cleanup.append(lb_rule) | |
| lb_rule.assign(self.apiclient, [vm1, vm2]) | |
| # ssh vm1 and vm2, start httpd, clear iptables | |
| ssh1 = vm1.get_ssh_client() | |
| ssh1.execute("service httpd start") | |
| ssh1.execute("iptables -F") | |
| ssh1.execute("echo test1 > /var/www/html/test.html") | |
| ssh2 = vm2.get_ssh_client() | |
| ssh2.execute("service httpd start") | |
| ssh2.execute("iptables -F") | |
| ssh2.execute("echo test2 > /var/www/html/test.html") | |
| # wait for tungsten instance service create | |
| time.sleep(120) | |
| # check if load balancing was apply and content was load balancing with round robin method | |
| contents = ["test1", "test2"] | |
| headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36'} | |
| r1 = requests.get("http://%s/test.html" % public_ip.ipaddress.ipaddress, headers=headers) | |
| self.assertEqual(r1.status_code, 200, "Load balance was created and applied to vms") | |
| self.logger.info("http response 1 content %s" % r1.text) | |
| contents.remove(r1.text.rstrip()) | |
| self.assertEqual(len(contents), 1, "Contents was load balancing with test1 or test2") | |
| r2 = requests.get("http://%s/test.html" % public_ip.ipaddress.ipaddress, headers=headers) | |
| self.assertEqual(r2.status_code, 200, "Load balance was created and applied to vms") | |
| self.logger.info("http response 2 content %s" % r2.text) | |
| contents.remove(r2.text.rstrip()) | |
| self.assertEqual(len(contents), 0, "Contents was load balancing with the rest of contents") | |
| return | |
| @skipTestIf("not_tungsten_fabric_zone") | |
| @attr(tags=["tungstenfabric"], required_hardware="false") | |
| def test_01_logicalrouter(self): | |
| # create network offering | |
| network_offering = NetworkOffering.create(self.apiclient, self.services["network_offering"]) | |
| network_offering.update(self.apiclient, state='Enabled') | |
| self.cleanup.append(network_offering) | |
| # create network 1 | |
| network1 = Network.create( | |
| self.apiclient, | |
| self.services["networks"]["network1"], | |
| networkofferingid=network_offering.id, | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid | |
| ) | |
| self.cleanup.append(network1) | |
| # create virtual machine 1 | |
| vm1 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm1"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network1.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced' | |
| ) | |
| self.cleanup.append(vm1) | |
| # create network 2 | |
| network2 = Network.create( | |
| self.apiclient, | |
| self.services["networks"]["network2"], | |
| networkofferingid=network_offering.id, | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid | |
| ) | |
| self.cleanup.append(network2) | |
| # create virtual machine 2 | |
| vm2 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm2"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network2.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced' | |
| ) | |
| self.cleanup.append(vm2) | |
| ssh1 = vm1.get_ssh_client() | |
| res1 = ssh1.execute("ping -c1 %s" % vm2.ipaddress) | |
| self.assertEqual( | |
| str(res1).count("0 received"), | |
| 1, | |
| "Ping vm2 from vm1 should be not successful" | |
| ) | |
| logicalrouter = LogicalRouter.create( | |
| self.apiclient, | |
| self.zone.id, | |
| self.services["logicalrouter"]["name"] | |
| ) | |
| self.cleanup.append(logicalrouter) | |
| LogicalRouter.add( | |
| self.apiclient, | |
| self.zone.id, | |
| logicalrouter.uuid, | |
| network1.id) | |
| LogicalRouter.add( | |
| self.apiclient, | |
| self.zone.id, | |
| logicalrouter.uuid, | |
| network2.id) | |
| # open firewall rule for network 1 | |
| EgressFireWallRule.create( | |
| apiclient=self.apiclient, | |
| networkid=network1.id, | |
| protocol='All', | |
| cidrlist='0.0.0.0/0' | |
| ) | |
| # open firewall rule for network 2 | |
| EgressFireWallRule.create( | |
| apiclient=self.apiclient, | |
| networkid=network2.id, | |
| protocol='All', | |
| cidrlist='0.0.0.0/0' | |
| ) | |
| ssh2 = vm1.get_ssh_client() | |
| res2 = ssh2.execute("ping -c1 %s" % vm2.ipaddress) | |
| self.assertEqual( | |
| str(res2).count("1 received"), | |
| 1, | |
| "Ping vm2 from vm1 should be successful" | |
| ) | |
| LogicalRouter.remove( | |
| self.apiclient, | |
| self.zone.id, | |
| logicalrouter.uuid, | |
| network1.id) | |
| LogicalRouter.remove( | |
| self.apiclient, | |
| self.zone.id, | |
| logicalrouter.uuid, | |
| network2.id) | |
| return | |
| @skipTestIf("not_tungsten_fabric_zone") | |
| @attr(tags=["tungstenfabric"], required_hardware="false") | |
| def test_01_firewall(self): | |
| # create network offering | |
| network_offering = NetworkOffering.create(self.apiclient, self.services["network_offering"]) | |
| network_offering.update(self.apiclient, state='Enabled') | |
| self.cleanup.append(network_offering) | |
| # create network | |
| network = Network.create( | |
| self.apiclient, | |
| self.services["networks"]["network1"], | |
| networkofferingid=network_offering.id, | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid | |
| ) | |
| self.cleanup.append(network) | |
| # create virtual machine | |
| vm = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm1"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced' | |
| ) | |
| self.cleanup.append(vm) | |
| # ssh vm, ping google.com and verified response package | |
| ssh1 = vm.get_ssh_client() | |
| res1 = ssh1.execute("ping -c1 google.com") | |
| self.assertEqual( | |
| str(res1).count("0 received"), | |
| 1, | |
| "Ping google.com from vm should be fail" | |
| ) | |
| # open firewall rule | |
| EgressFireWallRule.create( | |
| apiclient=self.apiclient, | |
| networkid=network.id, | |
| protocol='All', | |
| cidrlist='0.0.0.0/0' | |
| ) | |
| # wait for vm start | |
| time.sleep(30) | |
| # ssh vm, ping google.com and verified response package | |
| ssh2 = vm.get_ssh_client() | |
| res2 = ssh2.execute("ping -c1 google.com") | |
| self.assertEqual( | |
| str(res2).count("1 received"), | |
| 1, | |
| "Ping google.com from vm should be successful" | |
| ) | |
| return | |
| @skipTestIf("not_tungsten_fabric_zone") | |
| @attr(tags=["tungstenfabric"], required_hardware="false") | |
| def test_01_network_policy(self): | |
| # create network offering | |
| network_offering = NetworkOffering.create(self.apiclient, self.services["network_offering"]) | |
| network_offering.update(self.apiclient, state='Enabled') | |
| self.cleanup.append(network_offering) | |
| # create network | |
| network = Network.create( | |
| self.apiclient, | |
| self.services["networks"]["network1"], | |
| networkofferingid=network_offering.id, | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid | |
| ) | |
| self.cleanup.append(network) | |
| networkpolicy = NetworkPolicy.create( | |
| self.apiclient, | |
| self.zone.id, | |
| self.services["network_policy"]["policy1"]["name"] | |
| ) | |
| self.cleanup.append(networkpolicy) | |
| self.assertEqual( | |
| is_object_created(self.apiclient, self.zone.id, "network-policy", networkpolicy.uuid), | |
| True, "Check if network policy was created in tungsten") | |
| # create virtual machine | |
| vm = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm1"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced' | |
| ) | |
| self.cleanup.append(vm) | |
| ssh = vm.get_ssh_client() | |
| res = ssh.execute("ping -c1 google.com") | |
| self.assertEqual( | |
| str(res).count("0 received"), | |
| 1, | |
| "Ping google.com from vm should not be successful" | |
| ) | |
| NetworkPolicy.apply( | |
| self.apiclient, | |
| self.zone.id, | |
| network.id, | |
| networkpolicy.uuid, | |
| 1, | |
| 1 | |
| ) | |
| policyrule = PolicyRule.create( | |
| self.apiclient, | |
| self.zone.id, | |
| networkpolicy.uuid, | |
| self.services["network_policy"]["policy1"]["rules"]["rule1"]["action"], | |
| self.services["network_policy"]["policy1"]["rules"]["rule1"]["direction"], | |
| self.services["network_policy"]["policy1"]["rules"]["rule1"]["protocol"], | |
| self.services["network_policy"]["policy1"]["rules"]["rule1"]["srcnetwork"], | |
| self.services["network_policy"]["policy1"]["rules"]["rule1"]["srcipprefix"], | |
| self.services["network_policy"]["policy1"]["rules"]["rule1"]["srcipprefixlend"], | |
| self.services["network_policy"]["policy1"]["rules"]["rule1"]["srcstartport"], | |
| self.services["network_policy"]["policy1"]["rules"]["rule1"]["srcendport"], | |
| self.services["network_policy"]["policy1"]["rules"]["rule1"]["destnetwork"], | |
| self.services["network_policy"]["policy1"]["rules"]["rule1"]["destipprefix"], | |
| self.services["network_policy"]["policy1"]["rules"]["rule1"]["destipprefixlen"], | |
| self.services["network_policy"]["policy1"]["rules"]["rule1"]["deststartport"], | |
| self.services["network_policy"]["policy1"]["rules"]["rule1"]["destendport"] | |
| ) | |
| ssh1 = vm.get_ssh_client() | |
| res1 = ssh1.execute("ping -c1 google.com") | |
| self.assertEqual( | |
| str(res1).count("1 received"), | |
| 1, | |
| "Ping google.com from vm should be successful" | |
| ) | |
| PolicyRule.delete( | |
| self.apiclient, | |
| self.zone.id, | |
| networkpolicy.uuid, | |
| policyrule.uuid | |
| ) | |
| NetworkPolicy.remove( | |
| self.apiclient, | |
| self.zone.id, | |
| network.id, | |
| networkpolicy.uuid | |
| ) | |
| return | |
| @skipTestIf("not_tungsten_fabric_zone") | |
| @attr(tags=["tungstenfabric"], required_hardware="false") | |
| def test_01_application_policy_set(self): | |
| # create network offering | |
| network_offering = NetworkOffering.create(self.apiclient, self.services["network_offering"]) | |
| network_offering.update(self.apiclient, state='Enabled') | |
| self.cleanup.append(network_offering) | |
| # create network | |
| network = Network.create( | |
| self.apiclient, | |
| self.services["networks"]["network1"], | |
| networkofferingid=network_offering.id, | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid | |
| ) | |
| self.cleanup.append(network) | |
| # create virtual machine 1 | |
| vm1 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm1"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced' | |
| ) | |
| self.cleanup.append(vm1) | |
| # create virtual machine 2 | |
| vm2 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm2"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced' | |
| ) | |
| self.cleanup.append(vm2) | |
| # create virtual machine 3 | |
| vm3 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm3"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced' | |
| ) | |
| self.cleanup.append(vm3) | |
| applicationtag = TungstenTag.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| tagtype="application", | |
| tagvalue="webapp" | |
| ) | |
| self.cleanup.append(applicationtag) | |
| frontendtag = TungstenTag.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| tagtype="tier", | |
| tagvalue="frontend" | |
| ) | |
| self.cleanup.append(frontendtag) | |
| backendtag = TungstenTag.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| tagtype="tier", | |
| tagvalue="backend" | |
| ) | |
| self.cleanup.append(backendtag) | |
| aps = ApplicationPolicySet.create( | |
| self.apiclient, | |
| self.zone.id, | |
| self.services["applicationpolicysets"]["aps1"]["name"] | |
| ) | |
| self.cleanup.append(aps) | |
| frontendpolicy = FirewallPolicy.create( | |
| self.apiclient, | |
| self.zone.id, | |
| aps.uuid, | |
| self.services["firewallpolicys"]["frontend"]["name"], | |
| 1 | |
| ) | |
| self.cleanup.append(frontendpolicy) | |
| internetpolicy = FirewallPolicy.create( | |
| self.apiclient, | |
| self.zone.id, | |
| aps.uuid, | |
| self.services["firewallpolicys"]["internet"]["name"], | |
| 3 | |
| ) | |
| self.cleanup.append(internetpolicy) | |
| hostpolicy = FirewallPolicy.create( | |
| self.apiclient, | |
| self.zone.id, | |
| aps.uuid, | |
| self.services["firewallpolicys"]["host"]["name"], | |
| 4 | |
| ) | |
| self.cleanup.append(hostpolicy) | |
| anyservicegroup = ServiceGroup.create( | |
| self.apiclient, | |
| self.zone.id, | |
| self.services["servicegroups"]["any"]["name"], | |
| self.services["servicegroups"]["any"]["protocol"], | |
| self.services["servicegroups"]["any"]["startport"], | |
| self.services["servicegroups"]["any"]["endport"] | |
| ) | |
| self.cleanup.append(anyservicegroup) | |
| frontendrule = FirewallRule.create( | |
| self.apiclient, | |
| self.zone.id, | |
| frontendpolicy.uuid, | |
| name=self.services["firewallrules"]["frontend"]["name"], | |
| action=self.services["firewallrules"]["frontend"]["action"], | |
| direction=self.services["firewallrules"]["frontend"]["direction"], | |
| servicegroupuuid=anyservicegroup.uuid, | |
| srctaguuid=frontendtag.uuid, | |
| desttaguuid=backendtag.uuid, | |
| sequence=1 | |
| ) | |
| self.cleanup.append(frontendrule) | |
| internetrule = FirewallRule.create( | |
| self.apiclient, | |
| self.zone.id, | |
| internetpolicy.uuid, | |
| name=self.services["firewallrules"]["internet"]["name"], | |
| action=self.services["firewallrules"]["internet"]["action"], | |
| direction=self.services["firewallrules"]["internet"]["direction"], | |
| servicegroupuuid=anyservicegroup.uuid, | |
| srctaguuid=applicationtag.uuid, | |
| destnetworkuuid=network.id, | |
| sequence=1 | |
| ) | |
| self.cleanup.append(internetrule) | |
| publicnetwork = Network.list(self.apiclient, listall=True, issystem=True, traffictype="Public") | |
| hostrule = FirewallRule.create( | |
| self.apiclient, | |
| self.zone.id, | |
| hostpolicy.uuid, | |
| name=self.services["firewallrules"]["host"]["name"], | |
| action=self.services["firewallrules"]["host"]["action"], | |
| direction=self.services["firewallrules"]["host"]["direction"], | |
| servicegroupuuid=anyservicegroup.uuid, | |
| srcnetworkuuid=publicnetwork[0].id, | |
| desttaguuid=applicationtag.uuid, | |
| sequence=1 | |
| ) | |
| self.cleanup.append(hostrule) | |
| TungstenTag.apply( | |
| self.apiclient, | |
| self.zone.id, | |
| applicationpolicysetuuid=aps.uuid, | |
| taguuid=applicationtag.uuid | |
| ) | |
| TungstenTag.apply( | |
| self.apiclient, | |
| self.zone.id, | |
| taguuid=applicationtag.uuid, | |
| nicuuid=vm1.nic[0].id | |
| ) | |
| TungstenTag.apply( | |
| self.apiclient, | |
| self.zone.id, | |
| taguuid=frontendtag.uuid, | |
| nicuuid=vm1.nic[0].id | |
| ) | |
| TungstenTag.apply( | |
| self.apiclient, | |
| self.zone.id, | |
| taguuid=applicationtag.uuid, | |
| nicuuid=vm2.nic[0].id | |
| ) | |
| TungstenTag.apply( | |
| self.apiclient, | |
| self.zone.id, | |
| taguuid=backendtag.uuid, | |
| nicuuid=vm2.nic[0].id | |
| ) | |
| # open firewall rule for network | |
| EgressFireWallRule.create( | |
| apiclient=self.apiclient, | |
| networkid=network.id, | |
| protocol='All', | |
| cidrlist='0.0.0.0/0' | |
| ) | |
| ssh1 = vm1.get_ssh_client() | |
| ssh2 = vm2.get_ssh_client() | |
| ssh3 = vm3.get_ssh_client() | |
| # vm1 can access to internet | |
| res1 = ssh1.execute("ping -c1 google.com") | |
| self.assertEqual( | |
| str(res1).count("1 received"), | |
| 1, | |
| "Ping google from vm1 should be successful" | |
| ) | |
| # vm2 can access to internet | |
| res2 = ssh2.execute("ping -c1 google.com") | |
| self.assertEqual( | |
| str(res2).count("1 received"), | |
| 1, | |
| "Ping google from vm2 should be successful" | |
| ) | |
| # vm3 can access to internet | |
| res3 = ssh3.execute("ping -c1 google.com") | |
| self.assertEqual( | |
| str(res3).count("1 received"), | |
| 1, | |
| "Ping google from vm3 should be successful" | |
| ) | |
| # vm3(outside) can not ping to vm1 | |
| res4 = ssh3.execute("ping -c1 %s" % vm1.ipaddress) | |
| self.assertEqual( | |
| str(res4).count("0 received"), | |
| 1, | |
| "Ping vm1 from vm3 should be not successful" | |
| ) | |
| # vm3(outside) can not ping to vm2 | |
| res5 = ssh3.execute("ping -c1 %s" % vm2.ipaddress) | |
| self.assertEqual( | |
| str(res5).count("0 received"), | |
| 1, | |
| "Ping vm2 from vm3 should be not successful" | |
| ) | |
| # vm1(frontend) can ping to vm2(backend) | |
| res6 = ssh1.execute("ping -c1 %s" % vm2.ipaddress) | |
| self.assertEqual( | |
| str(res6).count("1 received"), | |
| 1, | |
| "Ping vm1 from vm2 should be successful" | |
| ) | |
| TungstenTag.remove( | |
| self.apiclient, | |
| self.zone.id, | |
| applicationpolicysetuuid=aps.uuid, | |
| taguuid=applicationtag.uuid | |
| ) | |
| TungstenTag.remove( | |
| self.apiclient, | |
| self.zone.id, | |
| taguuid=applicationtag.uuid, | |
| nicuuid=vm1.nic[0].id | |
| ) | |
| TungstenTag.remove( | |
| self.apiclient, | |
| self.zone.id, | |
| taguuid=frontendtag.uuid, | |
| nicuuid=vm1.nic[0].id | |
| ) | |
| TungstenTag.remove( | |
| self.apiclient, | |
| self.zone.id, | |
| taguuid=applicationtag.uuid, | |
| nicuuid=vm2.nic[0].id | |
| ) | |
| TungstenTag.remove( | |
| self.apiclient, | |
| self.zone.id, | |
| taguuid=backendtag.uuid, | |
| nicuuid=vm2.nic[0].id | |
| ) | |
| return | |
| @skipTestIf("can_not_migrate") | |
| @attr(tags=["tungstenfabric"], required_hardware="false") | |
| def test_01_vm_migration(self): | |
| # create network offering | |
| network_offering = NetworkOffering.create(self.apiclient, self.services["network_offering"]) | |
| network_offering.update(self.apiclient, state='Enabled') | |
| self.cleanup.append(network_offering) | |
| # create network | |
| network = Network.create( | |
| self.apiclient, | |
| self.services["networks"]["network1"], | |
| networkofferingid=network_offering.id, | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid | |
| ) | |
| self.cleanup.append(network) | |
| # create virtual machine | |
| vm = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machines"]["vm1"], | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| networkids=[str(network.id)], | |
| zoneid=self.zone.id, | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| mode='advanced', | |
| hostid=self.hosts[0].id | |
| ) | |
| self.cleanup.append(vm) | |
| # open firewall rule for network 1 | |
| EgressFireWallRule.create( | |
| apiclient=self.apiclient, | |
| networkid=network.id, | |
| protocol='All', | |
| cidrlist='0.0.0.0/0' | |
| ) | |
| ssh = vm.get_ssh_client() | |
| res = ssh.execute("ping -c1 google.com") | |
| self.assertEqual( | |
| str(res).count("1 received"), | |
| 1, | |
| "Ping google.com from vm1 should be successful" | |
| ) | |
| cmd = migrateVirtualMachine.migrateVirtualMachineCmd() | |
| cmd.virtualmachineid = vm.id | |
| cmd.hostid = self.hosts[1].id | |
| migrate = self.apiclient.migrateVirtualMachine(cmd) | |
| ssh = vm.get_ssh_client() | |
| res = ssh.execute("ping -c1 google.com") | |
| self.assertEqual( | |
| str(res).count("1 received"), | |
| 1, | |
| "Ping google.com from vm1 should be successful" | |
| ) |