mirror of
https://github.com/apache/cloudstack.git
synced 2025-11-04 00:02:37 +01:00
818 lines
42 KiB
Python
818 lines
42 KiB
Python
# 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.
|
|
|
|
"""
|
|
Tests of acquiring IPs in multiple subnets for isolated network or vpc
|
|
"""
|
|
|
|
from nose.plugins.attrib import attr
|
|
from marvin.cloudstackTestCase import cloudstackTestCase, unittest
|
|
from marvin.lib.utils import (validateList,
|
|
get_host_credentials,
|
|
get_process_status,
|
|
cleanup_resources)
|
|
from marvin.lib.base import (Account,
|
|
Domain,
|
|
VirtualMachine,
|
|
ServiceOffering,
|
|
Zone,
|
|
Network,
|
|
NetworkOffering,
|
|
VPC,
|
|
VpcOffering,
|
|
NATRule,
|
|
PublicIPAddress,
|
|
PublicIpRange)
|
|
from marvin.lib.common import (get_domain,
|
|
get_zone,
|
|
get_free_vlan,
|
|
get_template,
|
|
list_hosts,
|
|
list_routers)
|
|
import logging
|
|
import random
|
|
class TestMultiplePublicIpSubnets(cloudstackTestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.testClient = super(
|
|
TestMultiplePublicIpSubnets,
|
|
cls).getClsTestClient()
|
|
cls.apiclient = cls.testClient.getApiClient()
|
|
cls.services = cls.testClient.getParsedTestDataConfig()
|
|
|
|
zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
|
|
cls.zone = Zone(zone.__dict__)
|
|
cls.template = get_template(cls.apiclient, cls.zone.id)
|
|
cls._cleanup = []
|
|
cls.skip = False
|
|
|
|
if str(cls.zone.securitygroupsenabled) == "True":
|
|
cls.skip = True
|
|
return
|
|
|
|
cls.hypervisor = cls.testClient.getHypervisorInfo()
|
|
if cls.hypervisor.lower() not in ['kvm']:
|
|
cls.skip = True
|
|
return
|
|
|
|
cls.logger = logging.getLogger("TestMultiplePublicIpSubnets")
|
|
cls.stream_handler = logging.StreamHandler()
|
|
cls.logger.setLevel(logging.DEBUG)
|
|
cls.logger.addHandler(cls.stream_handler)
|
|
|
|
# Get Zone, Domain and templates
|
|
cls.domain = get_domain(cls.apiclient)
|
|
|
|
# Create small service offering
|
|
cls.service_offering = ServiceOffering.create(
|
|
cls.apiclient,
|
|
cls.services["service_offerings"]["small"]
|
|
)
|
|
cls._cleanup.append(cls.service_offering)
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
cleanup_resources(cls.apiclient, cls._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def setUp(cls):
|
|
if cls.skip:
|
|
cls.skipTest("Test can be run only on advanced zone and KVM hypervisor")
|
|
cls.apiclient = cls.testClient.getApiClient()
|
|
cls.cleanup = []
|
|
return
|
|
|
|
def tearDown(cls):
|
|
try:
|
|
cleanup_resources(cls.apiclient, cls.cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def get_routers(self, network_id):
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
networkid=network_id,
|
|
listall=True)
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
self.assertNotEqual(
|
|
len(routers),
|
|
0,
|
|
"Check list router response"
|
|
)
|
|
return routers
|
|
|
|
def get_vpc_routers(self, vpc_id):
|
|
routers = list_routers(
|
|
self.apiclient,
|
|
vpcid=vpc_id,
|
|
listall=True)
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"Check for list routers response return valid data"
|
|
)
|
|
self.assertNotEqual(
|
|
len(routers),
|
|
0,
|
|
"Check list router response"
|
|
)
|
|
return routers
|
|
|
|
def get_router_host(self, router):
|
|
self.assertEqual(
|
|
router.state,
|
|
'Running',
|
|
"Check list router response for router state"
|
|
)
|
|
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]
|
|
if host.hypervisor.lower() not in "kvm":
|
|
return
|
|
host.user, host.password = get_host_credentials(self.config, host.ipaddress)
|
|
host.port=22
|
|
return host
|
|
|
|
def get_vpc_router_ips(self, router):
|
|
controlIp = None
|
|
sourcenatIp = None
|
|
tier1_Ip = None
|
|
tier2_Ip = None
|
|
for nic in router.nic:
|
|
if nic.traffictype == "Guest" and nic.ipaddress.startswith("10.250.1."):
|
|
tier1_Ip = nic.ipaddress
|
|
elif nic.traffictype == "Guest" and nic.ipaddress.startswith("10.250.2."):
|
|
tier2_Ip = nic.ipaddress
|
|
elif nic.traffictype == "Control":
|
|
controlIp = nic.ipaddress
|
|
elif sourcenatIp is None and nic.traffictype == "Public":
|
|
sourcenatIp = nic.ipaddress
|
|
return controlIp, sourcenatIp, tier1_Ip, tier2_Ip
|
|
|
|
def verify_network_interfaces_in_router(self, router, host, expectedNics):
|
|
command = 'ip link show |grep BROADCAST | cut -d ":" -f2 |tr -d " "|tr "\n" ","'
|
|
self.logger.debug("Executing command '%s'" % command)
|
|
result = get_process_status(
|
|
host.ipaddress,
|
|
host.port,
|
|
host.user,
|
|
host.password,
|
|
router.linklocalip,
|
|
command)[0]
|
|
self.assertEqual(result, expectedNics, "Expected nics are %s but actual nics are %s" %(expectedNics, result))
|
|
|
|
def verify_ip_address_in_router(self, router, host, ipaddress, device, isExist=True):
|
|
command = 'ip addr show %s |grep "inet "|cut -d " " -f6 |cut -d "/" -f1 |grep -w %s' % (device,ipaddress)
|
|
self.logger.debug("Executing command '%s'" % command)
|
|
result = get_process_status(
|
|
host.ipaddress,
|
|
host.port,
|
|
host.user,
|
|
host.password,
|
|
router.linklocalip,
|
|
command)
|
|
self.assertEqual(len(result) > 0 and result[0] == ipaddress, isExist, "ip %s verification failed" % ipaddress)
|
|
|
|
def get_free_ipaddress(self, vlanId):
|
|
ipaddresses = PublicIPAddress.list(
|
|
self.apiclient,
|
|
vlanid=vlanId,
|
|
state='Free'
|
|
)
|
|
self.assertEqual(
|
|
isinstance(ipaddresses, list),
|
|
True,
|
|
"List ipaddresses should return a valid response for Free ipaddresses"
|
|
)
|
|
random.shuffle(ipaddresses)
|
|
return ipaddresses[0].ipaddress
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_04_acquire_public_ips_in_vpc_with_redundant_vrs(self):
|
|
""" Acquire IPs in multiple subnets in vpc with redundant VRs
|
|
# Steps
|
|
# 1. get vpc offering with redundant VRs
|
|
# 2. create a vpc with the vpc offering
|
|
# verify the available nics in VR should be "eth0,eth1"
|
|
# verify the IPs in VR. eth0 -> control nic, eth1 -> source nat IP
|
|
# 3. create a tier in the vpc, and create a vm in the tier.
|
|
# verify the available nics in VR should be "eth0,eth1,eth2"
|
|
# verify the IPs in VR. eth0 -> control nic, eth1 -> source nat IP, eth2 -> tier 1
|
|
# 4. get a free public ip, assign to network, and create port forwarding rules (ssh) to the vm
|
|
# verify the available nics in VR should be "eth0,eth1,eth2"
|
|
# verify the IPs in VR. eth0 -> control nic, eth1 -> source nat IP, eth2 -> tier 1
|
|
# 5. remove the port forwarding rule, and release the new ip
|
|
# verify the available nics in VR should be "eth0,eth1,eth2"
|
|
# verify the IPs in VR. eth0 -> control nic, eth1 -> source nat IP, eth2 -> tier 1
|
|
|
|
# 6. create new public ip range 1
|
|
# 7. get a free ip in new ip range, assign to network, and create port forwarding rules (ssh) to the vm
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 1
|
|
# 8. get a free ip in new ip range, assign to network, and create port forwarding rules (ssh) to the vm
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 1/2
|
|
# 9. get a free ip in new ip range, assign to network, and create port forwarding rules (ssh) to the vm
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 1/2/3
|
|
# 10. release new ip 2
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 1/3
|
|
# 11. release new ip 1
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 3
|
|
|
|
# 12. create a tier 2 in the vpc, and create a vm 2 in the tier2.
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 3, eth4 -> tier 2
|
|
|
|
# 13. create new public ip range 2
|
|
# 14. get a free ip 4 in new ip range 2, assign to network, and create port forwarding rules (ssh) to the vm
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4,eth5,"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 3, eth4 -> tier 2, eth5 -> new ip 4
|
|
# 15. get a free ip 5 in new ip range 2, assign to network, and create port forwarding rules (ssh) to the vm
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4,eth5,"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 3, eth4 -> tier 2, eth5 -> new ip 4/5
|
|
# 16. get a free ip 6 in new ip range 2, assign to network, and create port forwarding rules (ssh) to the vm
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4,eth5,"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 3, eth4 -> tier 2, eth5 -> new ip 4/5/6
|
|
# 17. release new ip 5
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4,eth5,"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 3, eth4 -> tier 2, eth5 -> new ip 4/6
|
|
# 18. release new ip 4
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4,eth5,"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 3, eth4 -> tier 2, eth5 -> new ip 6
|
|
"""
|
|
|
|
# Create new domain1
|
|
self.domain1 = Domain.create(
|
|
self.apiclient,
|
|
services=self.services["acl"]["domain1"],
|
|
parentdomainid=self.domain.id)
|
|
# Create account1
|
|
self.account1 = Account.create(
|
|
self.apiclient,
|
|
self.services["acl"]["accountD1"],
|
|
domainid=self.domain1.id
|
|
)
|
|
self.cleanup.append(self.account1)
|
|
self.cleanup.append(self.domain1)
|
|
|
|
# Create new domain1
|
|
self.domain1 = Domain.create(
|
|
self.apiclient,
|
|
services=self.services["acl"]["domain1"],
|
|
parentdomainid=self.domain.id)
|
|
# Create account1
|
|
self.account1 = Account.create(
|
|
self.apiclient,
|
|
self.services["acl"]["accountD1"],
|
|
domainid=self.domain1.id
|
|
)
|
|
self.cleanup.append(self.account1)
|
|
self.cleanup.append(self.domain1)
|
|
|
|
# 1. get vpc offering with redundant VRs
|
|
vpc_offering = VpcOffering.list(self.apiclient, name="Redundant VPC offering")
|
|
|
|
# 2. create a vpc with the vpc offering
|
|
self.services["vpc"]["cidr"] = "10.250.0.0/16"
|
|
self.vpc1 = VPC.create(
|
|
apiclient=self.apiclient,
|
|
services=self.services["vpc"],
|
|
vpcofferingid=vpc_offering[0].id,
|
|
zoneid=self.zone.id,
|
|
account=self.account1.name,
|
|
domainid=self.account1.domainid
|
|
)
|
|
|
|
# verify the available nics in VR should be "eth0,eth1"
|
|
# verify the IPs in VR. eth0 -> control nic, eth1 -> source nat IP
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
|
|
# 3. create a tier in the vpc, and create a vm in the tier.
|
|
vpc_tier_offerings = NetworkOffering.list(self.apiclient, name="DefaultIsolatedNetworkOfferingForVpcNetworks")
|
|
self.assertTrue(vpc_tier_offerings is not None and len(vpc_tier_offerings) > 0, "No VPC based network offering")
|
|
vpc_tier_offering = vpc_tier_offerings[0]
|
|
self.services["vpctier"] = {}
|
|
self.services["vpctier"]["name"] = "vpc-tier-1"
|
|
self.services["vpctier"]["displaytext"] = "vpc-tier-1"
|
|
vpc_tier_1 = Network.create(
|
|
apiclient=self.apiclient,
|
|
services=self.services["vpctier"],
|
|
accountid=self.account1.name,
|
|
domainid=self.domain1.id,
|
|
networkofferingid=vpc_tier_offering.id,
|
|
zoneid=self.zone.id,
|
|
vpcid=self.vpc1.id,
|
|
gateway="10.250.1.1",
|
|
netmask="255.255.255.0"
|
|
)
|
|
|
|
try:
|
|
self.virtual_machine1 = VirtualMachine.create(
|
|
self.apiclient,
|
|
self.services["virtual_machine"],
|
|
accountid=self.account1.name,
|
|
domainid=self.account1.domainid,
|
|
serviceofferingid=self.service_offering.id,
|
|
templateid=self.template.id,
|
|
zoneid=self.zone.id,
|
|
networkids=vpc_tier_1.id
|
|
)
|
|
except Exception as e:
|
|
self.fail("Exception while deploying virtual machine: %s" % e)
|
|
|
|
# verify the available nics in VR should be "eth0,eth1,eth2"
|
|
# verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
|
|
# 4. get a free public ip, assign to network, and create port forwarding rules (ssh) to the vm
|
|
ipaddress = PublicIPAddress.create(
|
|
self.apiclient,
|
|
zoneid=self.zone.id,
|
|
vpcid=self.vpc1.id,
|
|
)
|
|
nat_rule = NATRule.create(
|
|
self.apiclient,
|
|
self.virtual_machine1,
|
|
self.services["natrule"],
|
|
ipaddressid=ipaddress.ipaddress.id,
|
|
networkid=vpc_tier_1.id
|
|
)
|
|
# verify the available nics in VR should be "eth0,eth1,eth2"
|
|
# verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP/new ip
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress.ipaddress.ipaddress, "eth1", True)
|
|
|
|
# 5. release the new ip
|
|
ipaddress.delete(self.apiclient)
|
|
|
|
# verify the available nics in VR should be "eth0,eth1,eth2"
|
|
# verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress.ipaddress.ipaddress, "eth1", False)
|
|
|
|
# 6. create new public ip range 1
|
|
self.services["publiciprange"]["zoneid"] = self.zone.id
|
|
self.services["publiciprange"]["forvirtualnetwork"] = "true"
|
|
random_subnet_number = random.randrange(10,20)
|
|
self.services["publiciprange"]["vlan"] = get_free_vlan(
|
|
self.apiclient,
|
|
self.zone.id)[1]
|
|
self.services["publiciprange"]["gateway"] = "172.16." + str(random_subnet_number) + ".1"
|
|
self.services["publiciprange"]["startip"] = "172.16." + str(random_subnet_number) + ".2"
|
|
self.services["publiciprange"]["endip"] = "172.16." + str(random_subnet_number) + ".10"
|
|
self.services["publiciprange"]["netmask"] = "255.255.255.0"
|
|
self.public_ip_range1 = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.services["publiciprange"]
|
|
)
|
|
self.cleanup.append(self.public_ip_range1)
|
|
|
|
# 7. get a free ip in new ip range, assign to network, and create port forwarding rules (ssh) to the vm
|
|
ip_address_1 = self.get_free_ipaddress(self.public_ip_range1.vlan.id)
|
|
ipaddress_1 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
zoneid=self.zone.id,
|
|
vpcid=self.vpc1.id,
|
|
ipaddress=ip_address_1
|
|
)
|
|
|
|
nat_rule = NATRule.create(
|
|
self.apiclient,
|
|
self.virtual_machine1,
|
|
self.services["natrule"],
|
|
ipaddressid=ipaddress_1.ipaddress.id,
|
|
networkid=vpc_tier_1.id
|
|
)
|
|
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3"
|
|
# verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 1
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_1.ipaddress.ipaddress, "eth3", True)
|
|
|
|
# 8. get a free ip in new ip range, assign to network, and create port forwarding rules (ssh) to the vm
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3"
|
|
# verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 1, new ip 2,
|
|
ip_address_2 = self.get_free_ipaddress(self.public_ip_range1.vlan.id)
|
|
ipaddress_2 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
zoneid=self.zone.id,
|
|
vpcid=self.vpc1.id,
|
|
ipaddress=ip_address_2
|
|
)
|
|
|
|
nat_rule = NATRule.create(
|
|
self.apiclient,
|
|
self.virtual_machine1,
|
|
self.services["natrule"],
|
|
ipaddressid=ipaddress_2.ipaddress.id,
|
|
networkid=vpc_tier_1.id
|
|
)
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_1.ipaddress.ipaddress, "eth3", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_2.ipaddress.ipaddress, "eth3", True)
|
|
|
|
# 9. get a free ip in new ip range, assign to network, and create port forwarding rules (ssh) to the vm
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3"
|
|
# verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 1, new ip 2, new ip 3
|
|
ip_address_3 = self.get_free_ipaddress(self.public_ip_range1.vlan.id)
|
|
ipaddress_3 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
zoneid=self.zone.id,
|
|
vpcid=self.vpc1.id,
|
|
ipaddress=ip_address_3
|
|
)
|
|
|
|
nat_rule = NATRule.create(
|
|
self.apiclient,
|
|
self.virtual_machine1,
|
|
self.services["natrule"],
|
|
ipaddressid=ipaddress_3.ipaddress.id,
|
|
networkid=vpc_tier_1.id
|
|
)
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_1.ipaddress.ipaddress, "eth3", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_2.ipaddress.ipaddress, "eth3", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True)
|
|
|
|
# 10. release new ip 2
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3"
|
|
# verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 1, new ip 3
|
|
ipaddress_2.delete(self.apiclient)
|
|
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_1.ipaddress.ipaddress, "eth3", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_2.ipaddress.ipaddress, "eth3", False)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True)
|
|
|
|
# 11. release new ip 1
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3"
|
|
# verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 3
|
|
ipaddress_1.delete(self.apiclient)
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_1.ipaddress.ipaddress, "eth3", False)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_2.ipaddress.ipaddress, "eth3", False)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True)
|
|
|
|
# 12. create a tier in the vpc, and create a vm in the tier.
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4,"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 3, eth4 -> tier 2
|
|
self.services["vpctier"]["name"] = "vpc-tier-2"
|
|
self.services["vpctier"]["displaytext"] = "vpc-tier-2"
|
|
vpc_tier_2 = Network.create(
|
|
apiclient=self.apiclient,
|
|
services=self.services["vpctier"],
|
|
accountid=self.account1.name,
|
|
domainid=self.domain1.id,
|
|
networkofferingid=vpc_tier_offering.id,
|
|
zoneid=self.zone.id,
|
|
vpcid=self.vpc1.id,
|
|
gateway="10.250.2.1",
|
|
netmask="255.255.255.0"
|
|
)
|
|
|
|
try:
|
|
self.virtual_machine1 = VirtualMachine.create(
|
|
self.apiclient,
|
|
self.services["virtual_machine"],
|
|
accountid=self.account1.name,
|
|
domainid=self.account1.domainid,
|
|
serviceofferingid=self.service_offering.id,
|
|
templateid=self.template.id,
|
|
zoneid=self.zone.id,
|
|
networkids=vpc_tier_2.id
|
|
)
|
|
except Exception as e:
|
|
self.fail("Exception while deploying virtual machine: %s" % e)
|
|
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,eth4,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True)
|
|
self.verify_ip_address_in_router(router, host, tier2_Ip, "eth4", True)
|
|
|
|
# 13. create new public ip range 2
|
|
self.services["publiciprange"]["zoneid"] = self.zone.id
|
|
self.services["publiciprange"]["forvirtualnetwork"] = "true"
|
|
self.services["publiciprange"]["vlan"] = get_free_vlan(
|
|
self.apiclient,
|
|
self.zone.id)[1]
|
|
self.services["publiciprange"]["gateway"] = "172.16." + str(random_subnet_number + 1) + ".1"
|
|
self.services["publiciprange"]["startip"] = "172.16." + str(random_subnet_number + 1) + ".2"
|
|
self.services["publiciprange"]["endip"] = "172.16." + str(random_subnet_number + 1) + ".10"
|
|
self.services["publiciprange"]["netmask"] = "255.255.255.0"
|
|
self.public_ip_range2 = PublicIpRange.create(
|
|
self.apiclient,
|
|
self.services["publiciprange"]
|
|
)
|
|
self.cleanup.append(self.public_ip_range2)
|
|
|
|
# 14. get a free ip 4 in new ip range 2, assign to network, and create port forwarding rules (ssh) to the vm
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4,eth5,"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 3, eth4 -> tier 2, eth5 -> new ip 4
|
|
ip_address_4 = self.get_free_ipaddress(self.public_ip_range2.vlan.id)
|
|
ipaddress_4 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
zoneid=self.zone.id,
|
|
vpcid=self.vpc1.id,
|
|
ipaddress=ip_address_4
|
|
)
|
|
|
|
nat_rule = NATRule.create(
|
|
self.apiclient,
|
|
self.virtual_machine1,
|
|
self.services["natrule"],
|
|
ipaddressid=ipaddress_4.ipaddress.id,
|
|
networkid=vpc_tier_2.id
|
|
)
|
|
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,eth4,eth5,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True)
|
|
self.verify_ip_address_in_router(router, host, tier2_Ip, "eth4", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth5", True)
|
|
|
|
# 15. get a free ip 5 in new ip range 2, assign to network, and create port forwarding rules (ssh) to the vm
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4,eth5,"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 3, eth4 -> tier 2, eth5 -> new ip 4/5
|
|
ip_address_5 = self.get_free_ipaddress(self.public_ip_range2.vlan.id)
|
|
ipaddress_5 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
zoneid=self.zone.id,
|
|
vpcid=self.vpc1.id,
|
|
ipaddress=ip_address_5
|
|
)
|
|
|
|
nat_rule = NATRule.create(
|
|
self.apiclient,
|
|
self.virtual_machine1,
|
|
self.services["natrule"],
|
|
ipaddressid=ipaddress_5.ipaddress.id,
|
|
networkid=vpc_tier_2.id
|
|
)
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,eth4,eth5,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True)
|
|
self.verify_ip_address_in_router(router, host, tier2_Ip, "eth4", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth5", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth5", True)
|
|
|
|
# 16. get a free ip 6 in new ip range 2, assign to network, and create port forwarding rules (ssh) to the vm
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4,eth5,"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 3, eth4 -> tier 2, eth5 -> new ip 4/5/6
|
|
ip_address_6 = self.get_free_ipaddress(self.public_ip_range2.vlan.id)
|
|
ipaddress_6 = PublicIPAddress.create(
|
|
self.apiclient,
|
|
zoneid=self.zone.id,
|
|
vpcid=self.vpc1.id,
|
|
ipaddress=ip_address_6
|
|
)
|
|
|
|
nat_rule = NATRule.create(
|
|
self.apiclient,
|
|
self.virtual_machine1,
|
|
self.services["natrule"],
|
|
ipaddressid=ipaddress_6.ipaddress.id,
|
|
networkid=vpc_tier_2.id
|
|
)
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,eth4,eth5,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True)
|
|
self.verify_ip_address_in_router(router, host, tier2_Ip, "eth4", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth5", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth5", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth5", True)
|
|
|
|
# 17. release new ip 5
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4,eth5,"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 3, eth4 -> tier 2, eth5 -> new ip 4/6
|
|
ipaddress_5.delete(self.apiclient)
|
|
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,eth4,eth5,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True)
|
|
self.verify_ip_address_in_router(router, host, tier2_Ip, "eth4", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth5", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth5", False)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth5", True)
|
|
|
|
# 18. release new ip 4
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4,eth5,"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth3 -> new ip 3, eth4 -> tier 2, eth5 -> new ip 6
|
|
ipaddress_4.delete(self.apiclient)
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,eth4,eth5,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True)
|
|
self.verify_ip_address_in_router(router, host, tier2_Ip, "eth4", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth5", False)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth5", False)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth5", True)
|
|
|
|
# 19. release new ip 3
|
|
# verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4,eth5,"
|
|
# verify the IPs in VR. eth1 -> source nat IP, eth2 -> tier 1, eth4 -> tier 2, eth5 -> new ip 6
|
|
ipaddress_3.delete(self.apiclient)
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth4,eth5,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, tier2_Ip, "eth4", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth5", False)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth5", False)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth5", True)
|
|
|
|
# 20. restart tier1
|
|
vpc_tier_1.restart(self.apiclient)
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth4,eth5,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, tier2_Ip, "eth4", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth5", True)
|
|
|
|
#21. restart tier2
|
|
vpc_tier_2.restart(self.apiclient)
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth4,eth5,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, tier2_Ip, "eth4", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth5", True)
|
|
|
|
# 22. restart VPC
|
|
self.vpc1.restart(self.apiclient)
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth4,eth5,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, tier2_Ip, "eth4", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth5", True)
|
|
|
|
# 23. restart VPC with cleanup
|
|
self.vpc1.restart(self.apiclient, cleanup=True)
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,eth4,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth3", True)
|
|
self.verify_ip_address_in_router(router, host, tier2_Ip, "eth4", True)
|
|
|
|
# 24. restart VPC with cleanup, makeredundant=true
|
|
self.vpc1.restart(self.apiclient, cleanup=True, makeredundant=True)
|
|
routers = self.get_vpc_routers(self.vpc1.id)
|
|
for router in routers:
|
|
host = self.get_router_host(router)
|
|
self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,eth4,")
|
|
controlIp, sourcenatIp, tier1_Ip, tier2_Ip = self.get_vpc_router_ips(router)
|
|
self.verify_ip_address_in_router(router, host, controlIp, "eth0", True)
|
|
self.verify_ip_address_in_router(router, host, sourcenatIp, "eth1", True)
|
|
self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth2", True)
|
|
self.verify_ip_address_in_router(router, host, tier1_Ip, "eth3", True)
|
|
self.verify_ip_address_in_router(router, host, tier2_Ip, "eth4", True)
|