| # 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 a specified public IP for isolated network or vpc | |
| """ | |
| # Import Local Modules | |
| from nose.plugins.attrib import attr | |
| from marvin.cloudstackTestCase import cloudstackTestCase | |
| import unittest | |
| from marvin.cloudstackAPI import createVlanIpRange | |
| from marvin.lib.utils import (validateList, | |
| cleanup_resources) | |
| from marvin.lib.base import (Account, | |
| Domain, | |
| Configurations, | |
| VirtualMachine, | |
| ServiceOffering, | |
| VpcOffering, | |
| Zone, | |
| Network, | |
| VPC, | |
| PublicIPAddress, | |
| PublicIpRange) | |
| from marvin.lib.common import (get_domain, | |
| get_zone, | |
| get_free_vlan, | |
| get_template) | |
| import logging | |
| import random | |
| class TestAcquireSpecifiedPublicIp(cloudstackTestCase): | |
| @classmethod | |
| def setUpClass(cls): | |
| cls.testClient = super( | |
| TestAcquireSpecifiedPublicIp, | |
| 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 = [] | |
| if str(cls.zone.securitygroupsenabled) == "True": | |
| sys.exit(1) | |
| cls.logger = logging.getLogger("TestAcquireSpecifiedPublicIp") | |
| 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 new domain1 | |
| cls.domain1 = Domain.create( | |
| cls.apiclient, | |
| services=cls.services["acl"]["domain1"], | |
| parentdomainid=cls.domain.id) | |
| # Create account1 | |
| cls.account1 = Account.create( | |
| cls.apiclient, | |
| cls.services["acl"]["accountD1"], | |
| domainid=cls.domain1.id | |
| ) | |
| # Create domain2 | |
| cls.domain2 = Domain.create( | |
| cls.apiclient, | |
| services=cls.services["acl"]["domain2"], | |
| parentdomainid=cls.domain.id) | |
| # Create account2 | |
| cls.account2 = Account.create( | |
| cls.apiclient, | |
| cls.services["acl"]["accountD2"], | |
| domainid=cls.domain2.id | |
| ) | |
| cls.services["publiciprange"]["zoneid"] = cls.zone.id | |
| cls.services["publiciprange"]["forvirtualnetwork"] = "true" | |
| # Create public ip range 1 | |
| cls.services["publiciprange"]["vlan"] = get_free_vlan( | |
| cls.apiclient, | |
| cls.zone.id)[1] | |
| random_subnet_number = random.randrange(10,20) | |
| cls.services["publiciprange"]["gateway"] = "172.16." + \ | |
| str(random_subnet_number) + ".1" | |
| cls.services["publiciprange"]["startip"] = "172.16." + \ | |
| str(random_subnet_number) + ".2" | |
| cls.services["publiciprange"]["endip"] = "172.16." + \ | |
| str(random_subnet_number) + ".10" | |
| cls.services["publiciprange"]["netmask"] = "255.255.255.0" | |
| cls.public_ip_range1 = PublicIpRange.create( | |
| cls.apiclient, | |
| cls.services["publiciprange"] | |
| ) | |
| PublicIpRange.dedicate( | |
| cls.apiclient, | |
| cls.public_ip_range1.vlan.id, | |
| domainid=cls.account1.domainid | |
| ) | |
| # Create public ip range 2 | |
| cls.services["publiciprange"]["vlan"] = get_free_vlan( | |
| cls.apiclient, | |
| cls.zone.id)[1] | |
| cls.services["publiciprange"]["gateway"] = "172.16." + \ | |
| str(random_subnet_number + 1) + ".1" | |
| cls.services["publiciprange"]["startip"] = "172.16." + \ | |
| str(random_subnet_number + 1) + ".2" | |
| cls.services["publiciprange"]["endip"] = "172.16." + \ | |
| str(random_subnet_number + 1) + ".10" | |
| cls.services["publiciprange"]["netmask"] = "255.255.255.0" | |
| cls.public_ip_range2 = PublicIpRange.create( | |
| cls.apiclient, | |
| cls.services["publiciprange"] | |
| ) | |
| PublicIpRange.dedicate( | |
| cls.apiclient, | |
| cls.public_ip_range2.vlan.id, | |
| account=cls.account1.name, | |
| domainid=cls.account1.domainid | |
| ) | |
| # Create public ip range 3 | |
| cls.services["publiciprange"]["vlan"] = get_free_vlan( | |
| cls.apiclient, | |
| cls.zone.id)[1] | |
| cls.services["publiciprange"]["gateway"] = "172.16." + \ | |
| str(random_subnet_number + 2) + ".1" | |
| cls.services["publiciprange"]["startip"] = "172.16." + \ | |
| str(random_subnet_number + 2) + ".2" | |
| cls.services["publiciprange"]["endip"] = "172.16." + \ | |
| str(random_subnet_number + 2) + ".10" | |
| cls.services["publiciprange"]["netmask"] = "255.255.255.0" | |
| cls.public_ip_range3 = PublicIpRange.create( | |
| cls.apiclient, | |
| cls.services["publiciprange"] | |
| ) | |
| PublicIpRange.dedicate( | |
| cls.apiclient, | |
| cls.public_ip_range3.vlan.id, | |
| domainid=cls.account2.domainid | |
| ) | |
| # Create public ip range 4 | |
| cls.services["publiciprange"]["vlan"] = get_free_vlan( | |
| cls.apiclient, | |
| cls.zone.id)[1] | |
| cls.services["publiciprange"]["gateway"] = "172.16." + \ | |
| str(random_subnet_number + 3) + ".1" | |
| cls.services["publiciprange"]["startip"] = "172.16." + \ | |
| str(random_subnet_number + 3) + ".2" | |
| cls.services["publiciprange"]["endip"] = "172.16." + \ | |
| str(random_subnet_number + 3) + ".10" | |
| cls.services["publiciprange"]["netmask"] = "255.255.255.0" | |
| cls.public_ip_range4 = PublicIpRange.create( | |
| cls.apiclient, | |
| cls.services["publiciprange"] | |
| ) | |
| PublicIpRange.dedicate( | |
| cls.apiclient, | |
| cls.public_ip_range4.vlan.id, | |
| account=cls.account2.name, | |
| domainid=cls.account2.domainid | |
| ) | |
| # Create public ip range 5 | |
| cls.services["publiciprange"]["vlan"] = get_free_vlan( | |
| cls.apiclient, | |
| cls.zone.id)[1] | |
| cls.services["publiciprange"]["gateway"] = "172.16." + \ | |
| str(random_subnet_number + 4) + ".1" | |
| cls.services["publiciprange"]["startip"] = "172.16." + \ | |
| str(random_subnet_number + 4) + ".2" | |
| cls.services["publiciprange"]["endip"] = "172.16." + \ | |
| str(random_subnet_number + 4) + ".10" | |
| cls.services["publiciprange"]["netmask"] = "255.255.255.0" | |
| cls.public_ip_range5 = PublicIpRange.create( | |
| cls.apiclient, | |
| cls.services["publiciprange"] | |
| ) | |
| cls._cleanup.append(cls.account1) | |
| cls._cleanup.append(cls.domain1) | |
| cls._cleanup.append(cls.account2) | |
| cls._cleanup.append(cls.domain2) | |
| cls._cleanup.append(cls.public_ip_range1) | |
| cls._cleanup.append(cls.public_ip_range2) | |
| cls._cleanup.append(cls.public_ip_range3) | |
| cls._cleanup.append(cls.public_ip_range4) | |
| cls._cleanup.append(cls.public_ip_range5) | |
| @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): | |
| 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 | |
| @attr(tags=["advanced"], required_hardware="false") | |
| def test_01_acquire_public_ip_in_isolated_network(self): | |
| # Validate the following | |
| # 1. create a vm . it will create a network as well. | |
| # 2. assign a specified IP from subnet which is dedicated to domain1, it should succeed | |
| # 3. assign a specified IP from subnet which is dedicated to domain1/account1, it should succeed | |
| # 4. assign a specified IP from subnet which is dedicated to domain2, it should fail | |
| # 5. assign a specified IP from subnet which is dedicated to domain2/account2, it should fail | |
| # 6. update account setting use.system.public.ips to false, assign a specified IP from subnet which is public, it should fail | |
| # 7. update account setting use.system.public.ips to true, assign a specified IP from subnet which is public, it should succeed | |
| self.service_offering = ServiceOffering.create( | |
| self.apiclient, | |
| self.services["service_offering"] | |
| ) | |
| self.cleanup.append(self.service_offering) | |
| self.virtual_machine = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["small"], | |
| templateid=self.template.id, | |
| accountid=self.account1.name, | |
| domainid=self.account1.domainid, | |
| serviceofferingid=self.service_offering.id, | |
| zoneid=self.zone.id | |
| ) | |
| networks = Network.list( | |
| self.apiclient, | |
| account=self.account1.name, | |
| domainid=self.account1.domainid, | |
| listall=True | |
| ) | |
| self.assertEqual( | |
| isinstance(networks, list), | |
| True, | |
| "List networks should return a valid response for created network" | |
| ) | |
| network = networks[0] | |
| # Associate IP in range dedicated to domain1 | |
| ip_address_1 = self.get_free_ipaddress(self.public_ip_range1.vlan.id) | |
| ipaddress = PublicIPAddress.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| networkid=network.id, | |
| ipaddress=ip_address_1 | |
| ) | |
| self.assertIsNotNone( | |
| ipaddress, | |
| "Failed to Associate IP Address" | |
| ) | |
| self.cleanup.append(ipaddress) | |
| self.assertEqual(ipaddress.ipaddress.ipaddress, ip_address_1, "Associated IP is not same as specified") | |
| # Associate IP in range dedicated to domain1/account1 | |
| ip_address_2 = self.get_free_ipaddress(self.public_ip_range2.vlan.id) | |
| ipaddress = PublicIPAddress.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| networkid=network.id, | |
| ipaddress=ip_address_2 | |
| ) | |
| self.assertIsNotNone( | |
| ipaddress, | |
| "Failed to Associate IP Address" | |
| ) | |
| self.cleanup.append(ipaddress) | |
| self.assertEqual(ipaddress.ipaddress.ipaddress, ip_address_2, "Associated IP is not same as specified") | |
| # Associate IP in range dedicated to domain2 | |
| ip_address_3 = self.get_free_ipaddress(self.public_ip_range3.vlan.id) | |
| with self.assertRaises(Exception): | |
| ipaddress = PublicIPAddress.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| networkid=network.id, | |
| ipaddress=ip_address_3 | |
| ) | |
| # Associate IP in range dedicated to domain2/account2 | |
| ip_address_4 = self.get_free_ipaddress(self.public_ip_range4.vlan.id) | |
| with self.assertRaises(Exception): | |
| ipaddress = PublicIPAddress.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| networkid=network.id, | |
| ipaddress=ip_address_4 | |
| ) | |
| # Associate IP in public IP pool | |
| Configurations.update( | |
| self.apiclient, | |
| name="use.system.public.ips", | |
| value="false", | |
| accountid=self.account1.id | |
| ) | |
| ip_address_5 = self.get_free_ipaddress(self.public_ip_range5.vlan.id) | |
| with self.assertRaises(Exception): | |
| ipaddress = PublicIPAddress.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| networkid=network.id, | |
| ipaddress=ip_address_5 | |
| ) | |
| Configurations.update( | |
| self.apiclient, | |
| name="use.system.public.ips", | |
| value="true", | |
| accountid=self.account1.id | |
| ) | |
| ipaddress = PublicIPAddress.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| networkid=network.id, | |
| ipaddress=ip_address_5 | |
| ) | |
| self.assertIsNotNone( | |
| ipaddress, | |
| "Failed to Associate IP Address" | |
| ) | |
| self.cleanup.append(ipaddress) | |
| self.assertEqual(ipaddress.ipaddress.ipaddress, ip_address_5, "Associated IP is not same as specified") | |
| self.cleanup.append(self.virtual_machine) | |
| self.cleanup.append(self.service_offering) | |
| return | |
| @attr(tags=["advanced"], required_hardware="false") | |
| def test_02_acquire_public_ip_in_vpc(self): | |
| # Validate the following | |
| # 1. create a VPC with default offering. | |
| # 2. assign a specified IP from subnet which is dedicated to domain1, it should succeed | |
| # 3. assign a specified IP from subnet which is dedicated to domain1/account1, it should succeed | |
| # 4. assign a specified IP from subnet which is dedicated to domain2, it should fail | |
| # 5. assign a specified IP from subnet which is dedicated to domain2/account2, it should fail | |
| # 6. update account setting use.system.public.ips to false, assign a specified IP from subnet which is public, it should fail | |
| # 7. update account setting use.system.public.ips to true, assign a specified IP from subnet which is public, it should succeed | |
| vpcOffering = VpcOffering.list(self.apiclient, name="Default VPC offering") | |
| vpc = VPC.create( | |
| apiclient=self.apiclient, | |
| services=self.services["vpc"], | |
| vpcofferingid=vpcOffering[0].id, | |
| zoneid=self.zone.id, | |
| account=self.account1.name, | |
| domainid=self.account1.domainid | |
| ) | |
| # Associate IP in range dedicated to domain1 | |
| ip_address_1 = self.get_free_ipaddress(self.public_ip_range1.vlan.id) | |
| ipaddress = PublicIPAddress.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| vpcid=vpc.id, | |
| ipaddress=ip_address_1 | |
| ) | |
| self.assertIsNotNone( | |
| ipaddress, | |
| "Failed to Associate IP Address" | |
| ) | |
| self.cleanup.append(ipaddress) | |
| self.assertEqual(ipaddress.ipaddress.ipaddress, ip_address_1, "Associated IP is not same as specified") | |
| # Associate IP in range dedicated to domain1/account1 | |
| ip_address_2 = self.get_free_ipaddress(self.public_ip_range2.vlan.id) | |
| ipaddress = PublicIPAddress.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| vpcid=vpc.id, | |
| ipaddress=ip_address_2 | |
| ) | |
| self.assertIsNotNone( | |
| ipaddress, | |
| "Failed to Associate IP Address" | |
| ) | |
| self.cleanup.append(ipaddress) | |
| self.assertEqual(ipaddress.ipaddress.ipaddress, ip_address_2, "Associated IP is not same as specified") | |
| # Associate IP in range dedicated to domain2 | |
| ip_address_3 = self.get_free_ipaddress(self.public_ip_range3.vlan.id) | |
| with self.assertRaises(Exception): | |
| ipaddress = PublicIPAddress.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| vpcid=vpc.id, | |
| ipaddress=ip_address_3 | |
| ) | |
| # Associate IP in range dedicated to domain2/account2 | |
| ip_address_4 = self.get_free_ipaddress(self.public_ip_range4.vlan.id) | |
| with self.assertRaises(Exception): | |
| ipaddress = PublicIPAddress.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| vpcid=vpc.id, | |
| ipaddress=ip_address_4 | |
| ) | |
| # Associate IP in public IP pool | |
| Configurations.update( | |
| self.apiclient, | |
| name="use.system.public.ips", | |
| value="false", | |
| accountid=self.account1.id | |
| ) | |
| ip_address_5 = self.get_free_ipaddress(self.public_ip_range5.vlan.id) | |
| with self.assertRaises(Exception): | |
| ipaddress = PublicIPAddress.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| vpcid=vpc.id, | |
| ipaddress=ip_address_5 | |
| ) | |
| Configurations.update( | |
| self.apiclient, | |
| name="use.system.public.ips", | |
| value="true", | |
| accountid=self.account1.id | |
| ) | |
| ipaddress = PublicIPAddress.create( | |
| self.apiclient, | |
| zoneid=self.zone.id, | |
| vpcid=vpc.id, | |
| ipaddress=ip_address_5 | |
| ) | |
| self.assertIsNotNone( | |
| ipaddress, | |
| "Failed to Associate IP Address" | |
| ) | |
| self.cleanup.append(ipaddress) | |
| self.assertEqual(ipaddress.ipaddress.ipaddress, ip_address_5, "Associated IP is not same as specified") | |
| self.cleanup.append(vpc) | |
| return | |
| 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 |