mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
e333f2705a
This PR fixes few issues:
- check ip range of new network instead of network cidr, so that the two networks can use same cidr but no IP conflicts.
- Private gateways: return vlan number only for root admins
- when update isolated network, check new guest vm cidr and IPs of neworks/vpc gateways associated to it
1226 lines
56 KiB
Python
1226 lines
56 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 for IP reservation feature
|
|
|
|
Test Plan: https://cwiki.apache.org/confluence/display/CLOUDSTACK/IP+Range+Reservation+within+a+Network+Test+Cases
|
|
|
|
Issue Link: https://issues.apache.org/jira/browse/CLOUDSTACK-2266
|
|
|
|
Feature Specifications: https://cwiki.apache.org/confluence/display/CLOUDSTACK/FS+-+IP+Range+Reservation+within+a+Network
|
|
"""
|
|
from marvin.cloudstackTestCase import cloudstackTestCase
|
|
import unittest
|
|
from marvin.lib.utils import validateList, cleanup_resources, verifyRouterState
|
|
from marvin.lib.base import (Account,
|
|
Network,
|
|
VirtualMachine,
|
|
Router,
|
|
ServiceOffering,
|
|
NetworkOffering)
|
|
from marvin.lib.common import (get_zone,
|
|
get_template,
|
|
get_domain,
|
|
wait_for_cleanup,
|
|
createEnabledNetworkOffering,
|
|
createNetworkRulesForVM,
|
|
verifyNetworkState)
|
|
from marvin.codes import (PASS, FAIL, FAILED, UNKNOWN, FAULT, PRIMARY,
|
|
NAT_RULE, STATIC_NAT_RULE)
|
|
import netaddr
|
|
|
|
import random
|
|
from nose.plugins.attrib import attr
|
|
from ddt import ddt, data
|
|
|
|
def createIsolatedNetwork(self, network_offering_id, gateway=None):
|
|
"""Create isolated network with given network offering and gateway if provided
|
|
and return"""
|
|
try:
|
|
isolated_network = Network.create(self.apiclient, self.testData["isolated_network"],
|
|
networkofferingid=network_offering_id,accountid=self.account.name,
|
|
domainid=self.domain.id,zoneid=self.zone.id,
|
|
gateway=gateway, netmask='255.255.255.0' if gateway else None)
|
|
except Exception as e:
|
|
return [FAIL, e]
|
|
return [PASS, isolated_network]
|
|
|
|
def matchNetworkGuestVmCIDR(self, networkid, guestvmcidr):
|
|
"""List networks with given network id and check if the guestvmcidr matches
|
|
with the given cidr"""
|
|
|
|
networks = Network.list(self.apiclient, id=networkid, listall=True)
|
|
self.assertEqual(validateList(networks)[0], PASS, "network list validation failed")
|
|
self.assertEqual(str(networks[0].cidr), guestvmcidr, "guestvmcidr of network %s \
|
|
does not match with the given value %s" % (networks[0].cidr, guestvmcidr))
|
|
|
|
return
|
|
|
|
def createVirtualMachine(self, network_id=None, ip_address=None):
|
|
"""Create and return virtual machine within network and ipaddress"""
|
|
virtual_machine = VirtualMachine.create(self.apiclient,
|
|
self.testData["virtual_machine"],
|
|
networkids=network_id,
|
|
serviceofferingid=self.service_offering.id,
|
|
accountid=self.account.name,
|
|
domainid=self.domain.id,
|
|
ipaddress=ip_address)
|
|
return virtual_machine
|
|
|
|
def CreateEnabledNetworkOffering(apiclient, networkServices):
|
|
"""Create network offering of given test data and enable it"""
|
|
|
|
result = createEnabledNetworkOffering(apiclient, networkServices)
|
|
assert result[0] == PASS, "Network offering creation/enabling failed due to %s" % result[2]
|
|
return result[1]
|
|
|
|
@ddt
|
|
class TestIpReservation(cloudstackTestCase):
|
|
"""Test IP Range Reservation with a Network
|
|
"""
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.testClient = super(TestIpReservation, cls).getClsTestClient()
|
|
cls.api_client = cls.testClient.getApiClient()
|
|
|
|
# Fill services from the external config file
|
|
cls.testData = cls.testClient.getParsedTestDataConfig()
|
|
|
|
# Get Zone, Domain and templates
|
|
cls.domain = get_domain(cls.api_client)
|
|
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
|
|
cls.template = get_template(
|
|
cls.api_client,
|
|
cls.zone.id,
|
|
cls.testData["ostype"]
|
|
)
|
|
if cls.template == FAILED:
|
|
assert False, "get_template() failed to return template with description %s" % cls.testData["ostype"]
|
|
cls.testData["domainid"] = cls.domain.id
|
|
cls.testData["zoneid"] = cls.zone.id
|
|
cls.testData["virtual_machine"]["zoneid"] = cls.zone.id
|
|
cls.testData["virtual_machine"]["template"] = cls.template.id
|
|
cls._cleanup = []
|
|
try:
|
|
cls.service_offering = ServiceOffering.create(
|
|
cls.api_client,
|
|
cls.testData["service_offering"]
|
|
)
|
|
cls._cleanup.append(cls.service_offering)
|
|
cls.isolated_network_offering = CreateEnabledNetworkOffering(cls.api_client,
|
|
cls.testData["isolated_network_offering"])
|
|
cls._cleanup.append(cls.isolated_network_offering)
|
|
cls.isolated_persistent_network_offering = CreateEnabledNetworkOffering(cls.api_client,
|
|
cls.testData["nw_off_isolated_persistent"])
|
|
cls._cleanup.append(cls.isolated_persistent_network_offering)
|
|
cls.isolated_network_offering_RVR = CreateEnabledNetworkOffering(cls.api_client,
|
|
cls.testData["nw_off_isolated_RVR"])
|
|
cls._cleanup.append(cls.isolated_network_offering_RVR)
|
|
except Exception as e:
|
|
cls.tearDownClass()
|
|
raise unittest.SkipTest("Failure in setUpClass: %s" % e)
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
# Cleanup resources used
|
|
cleanup_resources(cls.api_client, cls._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def setUp(self):
|
|
self.apiclient = self.testClient.getApiClient()
|
|
self.dbclient = self.testClient.getDbConnection()
|
|
self.cleanup = []
|
|
try:
|
|
self.account = Account.create(self.apiclient, self.testData["account"],
|
|
domainid=self.domain.id)
|
|
self.cleanup.append(self.account)
|
|
except Exception as e:
|
|
self.skipTest("Failed to create account: %s" % e)
|
|
return
|
|
|
|
def tearDown(self):
|
|
try:
|
|
# Clean up, terminate the resources created
|
|
cleanup_resources(self.apiclient, self.cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
@attr(tags=["advanced"])
|
|
def test_vm_create_after_reservation(self):
|
|
""" Test creating VM in network after IP reservation
|
|
# steps
|
|
# 1. Create vm in isolated network (LB through VR or Netscaler) with ip in guestvmcidr
|
|
# 2. Update guestvmcidr
|
|
# 3. Create another VM
|
|
# validation
|
|
# 1. Guest vm cidr should be successfully updated with correct value
|
|
# 2. Existing guest vm ip should not be changed after reservation
|
|
# 3. Newly created VM should get ip in guestvmcidr"""
|
|
|
|
networkOffering = self.isolated_network_offering
|
|
subnet = "10.1."+str(random.randrange(1,254))
|
|
gateway = subnet +".1"
|
|
resultSet = createIsolatedNetwork(self, networkOffering.id, gateway=gateway)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_network = resultSet[1]
|
|
guest_vm_cidr = subnet +".0/29"
|
|
|
|
try:
|
|
virtual_machine_1 = createVirtualMachine(self, network_id=isolated_network.id,
|
|
ip_address = subnet+".3")
|
|
except Exception as e:
|
|
self.fail("VM creation failed: %s" % e)
|
|
|
|
isolated_network.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
matchNetworkGuestVmCIDR(self, isolated_network.id, guest_vm_cidr)
|
|
vms = VirtualMachine.list(self.apiclient,
|
|
id=virtual_machine_1.id)
|
|
self.assertEqual(validateList(vms)[0], PASS, "vm list validation failed")
|
|
self.assertEqual(vms[0].nic[0].ipaddress,
|
|
virtual_machine_1.ipaddress,
|
|
"VM IP should not change after reservation")
|
|
try:
|
|
virtual_machine_2 = createVirtualMachine(self, network_id=isolated_network.id)
|
|
if netaddr.IPAddress(virtual_machine_2.ipaddress) not in netaddr.IPNetwork(guest_vm_cidr):
|
|
self.fail("Newly created VM doesn't get IP from reserverd CIDR")
|
|
except Exception as e:
|
|
self.fail("VM creation failed, cannot validate the condition: %s" % e)
|
|
return
|
|
|
|
@attr(tags=["advanced"])
|
|
def test_vm_create_outside_cidr_after_reservation(self):
|
|
""" Test create VM outside the range of reserved IPs
|
|
# steps
|
|
# 1. update guestvmcidr of persistent isolated network (LB through VR or
|
|
# Netscaler
|
|
# 2. create another VM with ip outside guestvmcidr
|
|
"""
|
|
# validation
|
|
# 1. guest vm cidr should be successfully updated with correct value
|
|
# 2 newly created VM should not be created and result in exception
|
|
|
|
networkOffering = self.isolated_persistent_network_offering
|
|
subnet = "10.1."+str(random.randrange(1,254))
|
|
gateway = subnet +".1"
|
|
resultSet = createIsolatedNetwork(self, networkOffering.id, gateway=gateway)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_network = resultSet[1]
|
|
guest_vm_cidr = subnet+".0/29"
|
|
|
|
isolated_network.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
matchNetworkGuestVmCIDR(self, isolated_network.id, guest_vm_cidr)
|
|
try:
|
|
createVirtualMachine(self, network_id=self.isolated_network.id,
|
|
ip_address=subnet+".9")
|
|
self.fail("vm should not be created ")
|
|
except Exception as e:
|
|
self.debug("exception as IP is outside of guestvmcidr %s" % e)
|
|
return
|
|
|
|
@attr(tags=["advanced"])
|
|
def test_update_cidr_multiple_vms_not_all_inclusive(self):
|
|
""" Test reserve IP range such that one of the VM is not included
|
|
# steps
|
|
# 1. Create two vms in isolated network
|
|
# 2. Update guestvmcidr of network such that only one of the ipaddress of vms
|
|
# is in the given range
|
|
# validation
|
|
# 1. Network updation with this new range should fail"""
|
|
|
|
subnet = "10.1."+str(random.randrange(1,254))
|
|
gateway = subnet +".1"
|
|
resultSet = createIsolatedNetwork(self, self.isolated_network_offering.id,
|
|
gateway=gateway)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_network = resultSet[1]
|
|
guest_vm_cidr = subnet+".0/29"
|
|
|
|
try:
|
|
createVirtualMachine(self, network_id=isolated_network.id,
|
|
ip_address=subnet+".3")
|
|
except Exception as e:
|
|
self.fail("VM creation failed: %s" % e)
|
|
|
|
try:
|
|
createVirtualMachine(self, network_id=isolated_network.id,
|
|
ip_address=subnet+".9")
|
|
except Exception as e:
|
|
self.fail("VM creation failed: %s" % e)
|
|
|
|
with self.assertRaises(Exception):
|
|
isolated_network.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
return
|
|
|
|
@attr(tags=["advanced"])
|
|
def test_update_cidr_single_vm_not_inclusive(self):
|
|
""" Test reserving IP range in network such that existing VM is outside the range
|
|
# steps
|
|
# 1. Create vm in isolated network
|
|
# 2. Update guestvmcidr of network such that ip address of vm
|
|
# is outside the given range
|
|
#
|
|
# validation
|
|
# 1. Network updation with this new range should fail"""
|
|
subnet = "10.1."+str(random.randrange(1,254))
|
|
gateway = subnet +".1"
|
|
resultSet = createIsolatedNetwork(self, self.isolated_network_offering.id,
|
|
gateway=gateway)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_network = resultSet[1]
|
|
guest_vm_cidr = subnet+".0/29"
|
|
|
|
try:
|
|
createVirtualMachine(self, network_id=isolated_network.id,
|
|
ip_address=subnet+".9")
|
|
except Exception as e:
|
|
self.fail("VM creation failed: %s" % e)
|
|
|
|
with self.assertRaises(Exception):
|
|
isolated_network.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
return
|
|
|
|
@data(NAT_RULE, STATIC_NAT_RULE)
|
|
@attr(tags=["advanced"], required_hardware="true")
|
|
def test_nat_rules(self, value):
|
|
""" Test NAT rules working with IP reservation
|
|
# steps
|
|
# 1. Create vm in persistent isolated network with ip in guestvmcidr
|
|
# 2. Create NAT/static NAT rule for this VM
|
|
# 3. Update guestvmcidr
|
|
# 4. Create another VM and create network rules for this vm too
|
|
#
|
|
# validation
|
|
# 1. Guest vm cidr should be successfully updated with correct value
|
|
# 2. Existing guest vm ip should not be changed after reservation
|
|
# 3. Newly created VM should get ip in guestvmcidr
|
|
# 4. The network rules should be working"""
|
|
|
|
subnet = "10.1."+str(random.randrange(1,254))
|
|
gateway = subnet +".1"
|
|
resultSet = createIsolatedNetwork(self, self.isolated_network_offering.id,
|
|
gateway=gateway)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_network = resultSet[1]
|
|
guest_vm_cidr = subnet+".0/29"
|
|
|
|
try:
|
|
virtual_machine_1 = createVirtualMachine(self, network_id=isolated_network.id,
|
|
ip_address=subnet+".3")
|
|
except Exception as e:
|
|
self.fail("VM creation failed: %s" % e)
|
|
|
|
result = createNetworkRulesForVM(self.apiclient, virtual_machine_1,value,
|
|
self.account, self.testData)
|
|
if result[0] == FAIL:
|
|
self.fail("Failed to create network rules for VM: %s" % result[1])
|
|
else:
|
|
ipaddress_1 = result[1]
|
|
virtual_machine_1.get_ssh_client(ipaddress=ipaddress_1.ipaddress.ipaddress)
|
|
|
|
isolated_network.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
matchNetworkGuestVmCIDR(self, isolated_network.id, guest_vm_cidr)
|
|
vms = VirtualMachine.list(self.apiclient, id=virtual_machine_1.id)
|
|
self.assertEqual(validateList(vms)[0], PASS, "vm list validation failed")
|
|
self.assertEqual(vms[0].nic[0].ipaddress,
|
|
virtual_machine_1.ipaddress,
|
|
"VM IP should not change after reservation")
|
|
try:
|
|
virtual_machine_2 = createVirtualMachine(self, network_id=isolated_network.id)
|
|
if netaddr.IPAddress(virtual_machine_2.ipaddress) not in netaddr.IPNetwork(guest_vm_cidr):
|
|
self.fail("Newly created VM doesn't get IP from reserverd CIDR")
|
|
except Exception as e:
|
|
self.fail("VM creation failed, cannot validate the condition: %s" % e)
|
|
|
|
result = createNetworkRulesForVM(self.apiclient, virtual_machine_2, value,
|
|
self.account, self.testData)
|
|
if result[0] == FAIL:
|
|
self.fail("Failed to create network rules for VM: %s" % result[1])
|
|
else:
|
|
ipaddress_2 = result[1]
|
|
virtual_machine_2.get_ssh_client(ipaddress=ipaddress_2.ipaddress.ipaddress)
|
|
return
|
|
|
|
@unittest.skip("Skip - WIP")
|
|
@attr(tags=["advanced"])
|
|
def test_RVR_network(self):
|
|
""" Test IP reservation in network with RVR
|
|
# steps
|
|
# 1. create vm in isolated network with RVR and ip in guestvmcidr
|
|
# 2. update guestvmcidr
|
|
# 3. List routers and stop the primary router, wait till backup router comes up
|
|
# 4. create another VM
|
|
#
|
|
# validation
|
|
# 1. Guest vm cidr should be successfully updated with correct value
|
|
# 2. Existing guest vm ip should not be changed after reservation
|
|
# 3. Newly created VM should get ip in guestvmcidr
|
|
# 4. Verify that the network has two routers associated with it
|
|
# 5. Backup router should come up when primary router is stopped"""
|
|
|
|
subnet = "10.1."+str(random.randrange(1,254))
|
|
gateway = subnet +".1"
|
|
resultSet = createIsolatedNetwork(self, self.isolated_network_offering_RVR.id,
|
|
gateway=gateway)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_network_RVR= resultSet[1]
|
|
guest_vm_cidr = subnet+".0/29"
|
|
|
|
try:
|
|
virtual_machine_1 = createVirtualMachine(self, network_id=isolated_network_RVR.id,
|
|
ip_address=subnet+".3")
|
|
except Exception as e:
|
|
self.fail("VM creation failed: %s" % e)
|
|
|
|
isolated_network_RVR.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
matchNetworkGuestVmCIDR(self, isolated_network_RVR.id, guest_vm_cidr)
|
|
vms = VirtualMachine.list(self.apiclient,
|
|
id=virtual_machine_1.id)
|
|
self.assertEqual(validateList(vms)[0], PASS, "vm list validation failed")
|
|
self.assertEqual(vms[0].nic[0].ipaddress,
|
|
virtual_machine_1.ipaddress,
|
|
"VM IP should not change after reservation")
|
|
|
|
self.debug("Listing routers for network: %s" % isolated_network_RVR.name)
|
|
routers = Router.list(self.apiclient, networkid=isolated_network_RVR.id, listall=True)
|
|
self.assertEqual(validateList(routers)[0], PASS, "Routers list validation failed")
|
|
self.assertEqual(len(routers), 2, "Length of the list router should be 2 (Backup & primary)")
|
|
|
|
if routers[0].redundantstate == PRIMARY:
|
|
primary_router = routers[0]
|
|
backup_router = routers[1]
|
|
else:
|
|
primary_router = routers[1]
|
|
backup_router = routers[0]
|
|
|
|
self.debug("Stopping router ID: %s" % primary_router.id)
|
|
|
|
try:
|
|
Router.stop(self.apiclient, id=primary_router.id)
|
|
except Exception as e:
|
|
self.fail("Failed to stop primary router due to error %s" % e)
|
|
|
|
# wait for VR to update state
|
|
wait_for_cleanup(self.apiclient, ["router.check.interval"])
|
|
|
|
result = verifyRouterState(primary_router.id, [UNKNOWN,FAULT])
|
|
if result[0] == FAIL:
|
|
self.fail(result[1])
|
|
result = verifyRouterState(backup_router.id, [PRIMARY])
|
|
if result[0] == FAIL:
|
|
self.fail(result[1])
|
|
|
|
try:
|
|
virtual_machine_2 = createVirtualMachine(self, network_id=isolated_network_RVR.id)
|
|
if netaddr.IPAddress(virtual_machine_2.ipaddress) not in netaddr.IPNetwork(guest_vm_cidr):
|
|
self.fail("Newly created VM doesn't get IP from reserverd CIDR")
|
|
except Exception as e:
|
|
self.fail("VM creation failed, cannot validate the condition: %s" % e)
|
|
return
|
|
|
|
@attr(tags=["advanced"])
|
|
def test_ip_reservation_in_multiple_networks_same_account(self):
|
|
""" Test IP reservation in multiple networks created in same account
|
|
# steps
|
|
# 1. Create two isolated networks with user defined cidr in same account
|
|
# Test below conditions for both the networks in the account
|
|
# 2. Create vm in persistent isolated network with ip in guestvmcidr
|
|
# 3. Update guestvmcidr
|
|
# 4. Create another VM
|
|
#
|
|
# validation
|
|
# 1. Guest vm cidr should be successfully updated with correct value
|
|
# 2. Existing guest vm ip should not be changed after reservation
|
|
# 3. Newly created VM should get ip in guestvmcidr"""
|
|
|
|
account_1 = Account.create(self.apiclient, self.testData["account"],
|
|
domainid=self.domain.id)
|
|
self.cleanup.append(account_1)
|
|
|
|
random_subnet = str(random.randrange(1,254))
|
|
gateway = "10.1." + random_subnet +".1"
|
|
isolated_network_1 = Network.create(self.apiclient, self.testData["isolated_network"],
|
|
networkofferingid=self.isolated_network_offering.id,accountid=account_1.name,
|
|
domainid=self.domain.id,zoneid=self.zone.id,
|
|
gateway=gateway, netmask='255.255.255.0')
|
|
guest_vm_cidr = "10.1."+random_subnet+".0/29"
|
|
|
|
try:
|
|
virtual_machine_1 = VirtualMachine.create(self.apiclient, self.testData["virtual_machine"],
|
|
networkids=isolated_network_1.id, serviceofferingid=self.service_offering.id,
|
|
accountid=account_1.name, domainid=self.domain.id,
|
|
ipaddress="10.1."+random_subnet+".3")
|
|
except Exception as e:
|
|
self.fail("VM creation failed: %s" % e)
|
|
|
|
isolated_network_1.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
matchNetworkGuestVmCIDR(self, isolated_network_1.id, guest_vm_cidr)
|
|
vms = VirtualMachine.list(self.apiclient,
|
|
id=virtual_machine_1.id)
|
|
self.assertEqual(validateList(vms)[0], PASS, "vm list validation failed")
|
|
self.assertEqual(vms[0].nic[0].ipaddress,
|
|
virtual_machine_1.ipaddress,
|
|
"VM IP should not change after reservation")
|
|
|
|
try:
|
|
virtual_machine_2 = VirtualMachine.create(self.apiclient, self.testData["virtual_machine"],
|
|
networkids=isolated_network_1.id, serviceofferingid=self.service_offering.id,
|
|
accountid=account_1.name, domainid=self.domain.id)
|
|
if netaddr.IPAddress(virtual_machine_2.ipaddress) not in netaddr.IPNetwork(guest_vm_cidr):
|
|
self.fail("Newly created VM doesn't get IP from reserverd CIDR")
|
|
except Exception as e:
|
|
self.fail("VM creation failed, cannot validate the condition: %s" % e)
|
|
|
|
random_subnet = str(random.randrange(1,254))
|
|
gateway = "10.1." + random_subnet +".1"
|
|
isolated_network_2 = Network.create(self.apiclient, self.testData["isolated_network"],
|
|
networkofferingid=self.isolated_network_offering.id,accountid=account_1.name,
|
|
domainid=self.domain.id,zoneid=self.zone.id,
|
|
gateway=gateway, netmask='255.255.255.0')
|
|
guest_vm_cidr = "10.1."+random_subnet+".0/29"
|
|
|
|
try:
|
|
virtual_machine_3 = VirtualMachine.create(self.apiclient, self.testData["virtual_machine"],
|
|
networkids=isolated_network_2.id, serviceofferingid=self.service_offering.id,
|
|
accountid=account_1.name, domainid=self.domain.id,
|
|
ipaddress="10.1."+random_subnet+".3")
|
|
except Exception as e:
|
|
self.fail("VM creation failed: %s" % e)
|
|
|
|
isolated_network_2.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
matchNetworkGuestVmCIDR(self, isolated_network_2.id, guest_vm_cidr)
|
|
vms = VirtualMachine.list(self.apiclient,
|
|
id=virtual_machine_3.id)
|
|
self.assertEqual(validateList(vms)[0], PASS, "vm list validation failed")
|
|
self.assertEqual(vms[0].nic[0].ipaddress,
|
|
virtual_machine_3.ipaddress,
|
|
"VM IP should not change after reservation")
|
|
|
|
try:
|
|
virtual_machine_4 = VirtualMachine.create(self.apiclient, self.testData["virtual_machine"],
|
|
networkids=isolated_network_2.id, serviceofferingid=self.service_offering.id,
|
|
accountid=account_1.name, domainid=self.domain.id)
|
|
if netaddr.IPAddress(virtual_machine_4.ipaddress) not in netaddr.IPNetwork(guest_vm_cidr):
|
|
self.fail("Newly created VM doesn't get IP from reserverd CIDR")
|
|
except Exception as e:
|
|
self.fail("VM creation failed, cannot validate the condition: %s" % e)
|
|
return
|
|
|
|
@ddt
|
|
class TestRestartNetwork(cloudstackTestCase):
|
|
"""Test Restart Network
|
|
"""
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.testClient = super(TestRestartNetwork, cls).getClsTestClient()
|
|
cls.api_client = cls.testClient.getApiClient()
|
|
|
|
# Fill services from the external config file
|
|
cls.testData = cls.testClient.getParsedTestDataConfig()
|
|
|
|
# Get Zone, Domain and templates
|
|
cls.domain = get_domain(cls.api_client)
|
|
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
|
|
cls.template = get_template(
|
|
cls.api_client,
|
|
cls.zone.id,
|
|
cls.testData["ostype"]
|
|
)
|
|
if cls.template == FAILED:
|
|
assert False, "get_template() failed to return template with description %s" % cls.testData["ostype"]
|
|
cls.testData["domainid"] = cls.domain.id
|
|
cls.testData["zoneid"] = cls.zone.id
|
|
cls.testData["virtual_machine"]["zoneid"] = cls.zone.id
|
|
cls.testData["virtual_machine"]["template"] = cls.template.id
|
|
cls._cleanup = []
|
|
try:
|
|
cls.service_offering = ServiceOffering.create(
|
|
cls.api_client,
|
|
cls.testData["service_offering"]
|
|
)
|
|
cls._cleanup.append(cls.service_offering)
|
|
cls.isolated_network_offering = CreateEnabledNetworkOffering(cls.api_client,
|
|
cls.testData["isolated_network_offering"])
|
|
cls._cleanup.append(cls.isolated_network_offering)
|
|
cls.isolated_persistent_network_offering = CreateEnabledNetworkOffering(cls.api_client,
|
|
cls.testData["nw_off_isolated_persistent"])
|
|
cls._cleanup.append(cls.isolated_persistent_network_offering)
|
|
except Exception as e:
|
|
cls.tearDownClass()
|
|
raise unittest.SkipTest("Failure in setUpClass: %s" % e)
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
# Cleanup resources used
|
|
cleanup_resources(cls.api_client, cls._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def setUp(self):
|
|
self.apiclient = self.testClient.getApiClient()
|
|
self.dbclient = self.testClient.getDbConnection()
|
|
self.cleanup = []
|
|
try:
|
|
self.account = Account.create(self.apiclient, self.testData["account"],
|
|
domainid=self.domain.id)
|
|
self.cleanup.append(self.account)
|
|
except Exception as e:
|
|
self.skipTest("Failed to create account: %s" % e)
|
|
return
|
|
|
|
def tearDown(self):
|
|
try:
|
|
# Clean up, terminate the resources created
|
|
cleanup_resources(self.apiclient, self.cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
@data(True, False)
|
|
@attr(tags=["advanced"])
|
|
def test_restart_network_with_cleanup(self, value):
|
|
""" Test IP reservation rules with network restart operation
|
|
# steps
|
|
# 1. Create vm in isolated network with ip in guestvmcidr
|
|
# 2. Update guestvmcidr
|
|
# 3. Restart network with cleanup True/False
|
|
# 4. Deploy another VM in the network
|
|
#
|
|
# validation
|
|
# 1. Guest vm cidr should be successfully updated with correct value
|
|
# 2. Existing guest vm ip should not be changed after reservation
|
|
# 3. Network should be restarted successfully with and without cleanup
|
|
# 4. Newly created VM should get ip in guestvmcidr"""
|
|
|
|
subnet = "10.1."+str(random.randrange(1,254))
|
|
gateway = subnet +".1"
|
|
resultSet = createIsolatedNetwork(self, self.isolated_network_offering.id,
|
|
gateway=gateway)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_network= resultSet[1]
|
|
guest_vm_cidr = subnet+".0/29"
|
|
|
|
try:
|
|
virtual_machine_1 = createVirtualMachine(self, network_id=isolated_network.id,
|
|
ip_address=subnet+".3")
|
|
except Exception as e:
|
|
self.fail("VM creation failed: %s" % e)
|
|
|
|
isolated_network.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
matchNetworkGuestVmCIDR(self, isolated_network.id, guest_vm_cidr)
|
|
vms = VirtualMachine.list(self.apiclient,
|
|
id=virtual_machine_1.id)
|
|
self.assertEqual(validateList(vms)[0], PASS, "vm list validation failed")
|
|
self.assertEqual(vms[0].nic[0].ipaddress,
|
|
virtual_machine_1.ipaddress,
|
|
"VM IP should not change after reservation")
|
|
|
|
#Restart Network
|
|
isolated_network.restart(self.apiclient, cleanup=value)
|
|
|
|
try:
|
|
virtual_machine_2 = createVirtualMachine(self, network_id=isolated_network.id)
|
|
if netaddr.IPAddress(virtual_machine_2.ipaddress) not in netaddr.IPNetwork(guest_vm_cidr):
|
|
self.fail("Newly created VM doesn't get IP from reserverd CIDR")
|
|
except Exception as e:
|
|
self.fail("VM creation failed, cannot validate the condition: %s" % e)
|
|
return
|
|
|
|
@ddt
|
|
class TestUpdateIPReservation(cloudstackTestCase):
|
|
"""Test Updating IP reservation multiple times
|
|
"""
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.testClient = super(TestUpdateIPReservation, cls).getClsTestClient()
|
|
cls.api_client = cls.testClient.getApiClient()
|
|
|
|
# Fill services from the external config file
|
|
cls.testData = cls.testClient.getParsedTestDataConfig()
|
|
|
|
# Get Zone, Domain and templates
|
|
cls.domain = get_domain(cls.api_client)
|
|
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
|
|
cls.template = get_template(
|
|
cls.api_client,
|
|
cls.zone.id,
|
|
cls.testData["ostype"]
|
|
)
|
|
if cls.template == FAILED:
|
|
assert False, "get_template() failed to return template with description %s" % cls.testData["ostype"]
|
|
cls.testData["domainid"] = cls.domain.id
|
|
cls.testData["zoneid"] = cls.zone.id
|
|
cls.testData["virtual_machine"]["zoneid"] = cls.zone.id
|
|
cls.testData["virtual_machine"]["template"] = cls.template.id
|
|
cls._cleanup = []
|
|
try:
|
|
cls.service_offering = ServiceOffering.create(
|
|
cls.api_client,
|
|
cls.testData["service_offering"]
|
|
)
|
|
cls._cleanup.append(cls.service_offering)
|
|
cls.isolated_network_offering = CreateEnabledNetworkOffering(cls.api_client,
|
|
cls.testData["isolated_network_offering"])
|
|
cls._cleanup.append(cls.isolated_network_offering)
|
|
cls.isolated_persistent_network_offering = CreateEnabledNetworkOffering(cls.api_client,
|
|
cls.testData["nw_off_isolated_persistent"])
|
|
cls._cleanup.append(cls.isolated_persistent_network_offering)
|
|
except Exception as e:
|
|
cls.tearDownClass()
|
|
raise unittest.SkipTest("Failure in setUpClass: %s" % e)
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
# Cleanup resources used
|
|
cleanup_resources(cls.api_client, cls._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def setUp(self):
|
|
self.apiclient = self.testClient.getApiClient()
|
|
self.dbclient = self.testClient.getDbConnection()
|
|
self.cleanup = []
|
|
try:
|
|
self.account = Account.create(self.apiclient, self.testData["account"],
|
|
domainid=self.domain.id)
|
|
self.cleanup.append(self.account)
|
|
except Exception as e:
|
|
self.skipTest("Failed to create account: %s" % e)
|
|
return
|
|
|
|
def tearDown(self):
|
|
try:
|
|
# Clean up, terminate the resources created
|
|
cleanup_resources(self.apiclient, self.cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
@data("existingVmInclusive", "existingVmExclusive")
|
|
@attr(tags=["advanced"])
|
|
def test_update_network_guestvmcidr(self, value):
|
|
""" Test updating guest vm cidr of the network after
|
|
VMs are already deployed in previous guest VM cidr
|
|
|
|
# steps
|
|
# 1. Create isolated network with user defined cidr
|
|
# 2. Deploy VM in the network
|
|
# 3. Try to update the guestvmcidr of the network with VM ip in the guestvmcidr and
|
|
# deploy another VM
|
|
# 4. Try to update the guestvmcidr of the network with VM ip outside the guestvmcidr
|
|
#
|
|
# validation
|
|
# 1. When vm IP is in the guestvmcidr, updation should be successful and
|
|
# new VM should get IP from this range
|
|
# 2. When VM IP is outside the guestvmcidr, updation should be unsuccessful"""
|
|
|
|
random_subnet = str(random.randrange(1,254))
|
|
gateway = "10.1." + random_subnet +".1"
|
|
resultSet = createIsolatedNetwork(self, self.isolated_network_offering.id,
|
|
gateway=gateway)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_network= resultSet[1]
|
|
guest_vm_cidr = "10.1."+random_subnet+".0/29"
|
|
|
|
try:
|
|
virtual_machine_1 = createVirtualMachine(self, network_id=isolated_network.id,
|
|
ip_address="10.1."+random_subnet+".3")
|
|
except Exception as e:
|
|
self.fail("VM creation failed: %s" % e)
|
|
|
|
isolated_network.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
matchNetworkGuestVmCIDR(self, isolated_network.id, guest_vm_cidr)
|
|
vms = VirtualMachine.list(self.apiclient,
|
|
id=virtual_machine_1.id)
|
|
self.assertEqual(validateList(vms)[0], PASS, "vm list validation failed")
|
|
self.assertEqual(vms[0].nic[0].ipaddress,
|
|
virtual_machine_1.ipaddress,
|
|
"VM IP should not change after reservation")
|
|
|
|
try:
|
|
virtual_machine_2 = createVirtualMachine(self, network_id=isolated_network.id)
|
|
if netaddr.IPAddress(virtual_machine_2.ipaddress) not in netaddr.IPNetwork(guest_vm_cidr):
|
|
self.fail("Newly created VM doesn't get IP from reserverd CIDR")
|
|
except Exception as e:
|
|
self.fail("VM creation failed, cannot validate the condition: %s" % e)
|
|
|
|
# Update guest vm cidr of network again
|
|
if value == "existingVmExclusive":
|
|
guest_vm_cidr = "10.1."+random_subnet+".10/29"
|
|
|
|
try:
|
|
isolated_network.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
self.fail("Network updation should fail")
|
|
except Exception as e:
|
|
self.debug("Failed to update guest VM cidr of network: %s" % e)
|
|
elif value == "existingVmInclusive":
|
|
guest_vm_cidr = "10.1."+random_subnet+".0/28"
|
|
|
|
try:
|
|
isolated_network.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
except Exception as e:
|
|
self.fail("Failed to update guest VM cidr of network: %s" % e)
|
|
|
|
matchNetworkGuestVmCIDR(self, isolated_network.id, guest_vm_cidr)
|
|
|
|
try:
|
|
virtual_machine_3 = createVirtualMachine(self, network_id=isolated_network.id)
|
|
if netaddr.IPAddress(virtual_machine_3.ipaddress) not in netaddr.IPNetwork(guest_vm_cidr):
|
|
self.fail("Newly created VM doesn't get IP from reserverd CIDR")
|
|
except Exception as e:
|
|
self.fail("VM creation failed, cannot validate the condition: %s" % e)
|
|
return
|
|
|
|
@ddt
|
|
class TestRouterOperations(cloudstackTestCase):
|
|
"""Test Router operations of network with IP reservation
|
|
"""
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.testClient = super(TestRouterOperations, cls).getClsTestClient()
|
|
cls.api_client = cls.testClient.getApiClient()
|
|
|
|
# Fill services from the external config file
|
|
cls.testData = cls.testClient.getParsedTestDataConfig()
|
|
|
|
# Get Zone, Domain and templates
|
|
cls.domain = get_domain(cls.api_client)
|
|
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
|
|
cls.template = get_template(
|
|
cls.api_client,
|
|
cls.zone.id,
|
|
cls.testData["ostype"]
|
|
)
|
|
if cls.template == FAILED:
|
|
assert False, "get_template() failed to return template with description %s" % cls.testData["ostype"]
|
|
cls.testData["domainid"] = cls.domain.id
|
|
cls.testData["zoneid"] = cls.zone.id
|
|
cls.testData["virtual_machine"]["zoneid"] = cls.zone.id
|
|
cls.testData["virtual_machine"]["template"] = cls.template.id
|
|
cls._cleanup = []
|
|
try:
|
|
cls.service_offering = ServiceOffering.create(
|
|
cls.api_client,
|
|
cls.testData["service_offering"]
|
|
)
|
|
cls._cleanup.append(cls.service_offering)
|
|
cls.isolated_network_offering = CreateEnabledNetworkOffering(cls.api_client,
|
|
cls.testData["isolated_network_offering"])
|
|
cls._cleanup.append(cls.isolated_network_offering)
|
|
cls.isolated_persistent_network_offering = CreateEnabledNetworkOffering(cls.api_client,
|
|
cls.testData["nw_off_isolated_persistent"])
|
|
cls._cleanup.append(cls.isolated_persistent_network_offering)
|
|
except Exception as e:
|
|
cls.tearDownClass()
|
|
raise unittest.SkipTest("Failure in setUpClass: %s" % e)
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
# Cleanup resources used
|
|
cleanup_resources(cls.api_client, cls._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def setUp(self):
|
|
self.apiclient = self.testClient.getApiClient()
|
|
self.dbclient = self.testClient.getDbConnection()
|
|
self.cleanup = []
|
|
try:
|
|
self.account = Account.create(self.apiclient, self.testData["account"],
|
|
domainid=self.domain.id)
|
|
self.cleanup.append(self.account)
|
|
except Exception as e:
|
|
self.skipTest("Failed to create account: %s" % e)
|
|
return
|
|
|
|
def tearDown(self):
|
|
try:
|
|
# Clean up, terminate the resources created
|
|
cleanup_resources(self.apiclient, self.cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
@attr(tags=["advanced"])
|
|
def test_reservation_after_router_restart(self):
|
|
""" Test IP reservation working before and after router is restarted
|
|
# steps
|
|
# 1. Update guestvmcidr of persistent isolated network
|
|
# 2. Reboot router
|
|
#
|
|
# validation
|
|
# 1. Guest vm cidr should be successfully updated with correct value
|
|
# 2. Network cidr should remain same after router restart"""
|
|
subnet = "10.1."+str(random.randrange(1,254))
|
|
gateway = subnet +".1"
|
|
resultSet = createIsolatedNetwork(self, self.isolated_persistent_network_offering.id,
|
|
gateway=gateway)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_network= resultSet[1]
|
|
guest_vm_cidr = subnet+".0/29"
|
|
|
|
isolated_network.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
matchNetworkGuestVmCIDR(self, isolated_network.id, guest_vm_cidr)
|
|
|
|
routers = Router.list(self.apiclient,
|
|
networkid=isolated_network.id,
|
|
listall=True)
|
|
self.assertEqual(validateList(routers)[0], PASS, "routers list validation failed")
|
|
if not routers:
|
|
self.fail("Router list should not be empty")
|
|
|
|
Router.reboot(self.apiclient, routers[0].id)
|
|
networks = Network.list(self.apiclient, id=isolated_network.id)
|
|
self.assertEqual(validateList(networks)[0], PASS, "networks list validation failed")
|
|
self.assertEqual(networks[0].cidr, guest_vm_cidr, "guestvmcidr should match after router reboot")
|
|
return
|
|
|
|
@attr(tags=["advanced"])
|
|
def test_destroy_recreate_router(self):
|
|
""" Test IP reservation working after destroying and recreating router
|
|
# steps
|
|
# 1. Create isolated network and deploy VM in it and update network with
|
|
# guestvmcidr
|
|
# 2. List the router associated with network and destroy the router
|
|
# 3. Restart the network
|
|
# 3. Deploy another VM in the network
|
|
#
|
|
# validation
|
|
# 1. Guest vm cidr should be successfully updated with correct value
|
|
# 2. existing guest vm ip should not be changed after reservation
|
|
# 3. Router should be destroyed and recreated when network is restarted
|
|
# 4. New VM should be deployed in the guestvmcidr"""
|
|
|
|
subnet = "10.1."+str(random.randrange(1,254))
|
|
gateway = subnet +".1"
|
|
resultSet = createIsolatedNetwork(self, self.isolated_network_offering.id,
|
|
gateway=gateway)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_network= resultSet[1]
|
|
guest_vm_cidr = subnet+".0/29"
|
|
|
|
try:
|
|
virtual_machine_1 = createVirtualMachine(self, network_id=isolated_network.id,
|
|
ip_address=subnet+".3")
|
|
except Exception as e:
|
|
self.fail("VM creation failed: %s" % e)
|
|
|
|
isolated_network.update(self.apiclient, guestvmcidr=guest_vm_cidr)
|
|
matchNetworkGuestVmCIDR(self, isolated_network.id, guest_vm_cidr)
|
|
vms = VirtualMachine.list(self.apiclient,
|
|
id=virtual_machine_1.id)
|
|
self.assertEqual(validateList(vms)[0], PASS, "vm list validation failed")
|
|
self.assertEqual(vms[0].nic[0].ipaddress,
|
|
virtual_machine_1.ipaddress,
|
|
"VM IP should not change after reservation")
|
|
|
|
# List router and destroy it
|
|
routers = Router.list(self.apiclient, networkid=isolated_network.id, listall=True)
|
|
self.assertEqual(validateList(routers)[0], PASS, "Routers list validation failed")
|
|
|
|
# Destroy Router
|
|
Router.destroy(self.apiclient, id=routers[0].id)
|
|
|
|
#Restart Network
|
|
isolated_network.restart(self.apiclient)
|
|
|
|
try:
|
|
virtual_machine_2 = createVirtualMachine(self, network_id=isolated_network.id)
|
|
if netaddr.IPAddress(virtual_machine_2.ipaddress) not in netaddr.IPNetwork(guest_vm_cidr):
|
|
self.fail("Newly created VM doesn't get IP from reserverd CIDR")
|
|
except Exception as e:
|
|
self.fail("VM creation failed, cannot validate the condition: %s" % e)
|
|
return
|
|
|
|
@ddt
|
|
class TestFailureScnarios(cloudstackTestCase):
|
|
"""Test failure scenarios related to IP reservation in network
|
|
"""
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.testClient = super(TestFailureScnarios, cls).getClsTestClient()
|
|
cls.api_client = cls.testClient.getApiClient()
|
|
|
|
# Fill services from the external config file
|
|
cls.testData = cls.testClient.getParsedTestDataConfig()
|
|
|
|
# Get Zone, Domain and templates
|
|
cls.domain = get_domain(cls.api_client)
|
|
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
|
|
cls.template = get_template(
|
|
cls.api_client,
|
|
cls.zone.id,
|
|
cls.testData["ostype"]
|
|
)
|
|
if cls.template == FAILED:
|
|
assert False, "get_template() failed to return template with description %s" % cls.testData["ostype"]
|
|
cls.testData["domainid"] = cls.domain.id
|
|
cls.testData["zoneid"] = cls.zone.id
|
|
cls.testData["virtual_machine"]["zoneid"] = cls.zone.id
|
|
cls.testData["virtual_machine"]["template"] = cls.template.id
|
|
cls._cleanup = []
|
|
try:
|
|
cls.service_offering = ServiceOffering.create(
|
|
cls.api_client,
|
|
cls.testData["service_offering"]
|
|
)
|
|
cls._cleanup.append(cls.service_offering)
|
|
cls.isolated_network_offering = CreateEnabledNetworkOffering(cls.api_client,
|
|
cls.testData["isolated_network_offering"])
|
|
cls._cleanup.append(cls.isolated_network_offering)
|
|
cls.isolated_persistent_network_offering = CreateEnabledNetworkOffering(cls.api_client,
|
|
cls.testData["nw_off_isolated_persistent"])
|
|
cls._cleanup.append(cls.isolated_persistent_network_offering)
|
|
|
|
cls.testData["shared_network_offering"]["specifyVlan"] = "True"
|
|
cls.testData["shared_network_offering"]["specifyIpRanges"] = "True"
|
|
|
|
#Create Network Offering
|
|
cls.shared_network_offering = NetworkOffering.create(cls.api_client,
|
|
cls.testData["shared_network_offering"],
|
|
conservemode=False)
|
|
cls._cleanup.append(cls.shared_network_offering)
|
|
|
|
#Update network offering state from disabled to enabled.
|
|
NetworkOffering.update(cls.shared_network_offering,cls.api_client,state="enabled")
|
|
except Exception as e:
|
|
cls.tearDownClass()
|
|
raise unittest.SkipTest("Failure in setUpClass: %s" % e)
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
try:
|
|
# Cleanup resources used
|
|
cleanup_resources(cls.api_client, cls._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
def setUp(self):
|
|
self.apiclient = self.testClient.getApiClient()
|
|
self.dbclient = self.testClient.getDbConnection()
|
|
self.cleanup = []
|
|
try:
|
|
self.account = Account.create(self.apiclient, self.testData["account"],
|
|
domainid=self.domain.id)
|
|
self.cleanup.append(self.account)
|
|
except Exception as e:
|
|
self.skipTest("Failed to create account: %s" % e)
|
|
return
|
|
|
|
def tearDown(self):
|
|
try:
|
|
# Clean up, terminate the resources created
|
|
cleanup_resources(self.apiclient, self.cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_network_not_implemented(self):
|
|
# steps
|
|
# 1. update guestvmcidr of isolated network (non persistent)
|
|
#
|
|
# validation
|
|
# should succeed although network is not in implemented state
|
|
|
|
networkOffering = self.isolated_network_offering
|
|
resultSet = createIsolatedNetwork(self, networkOffering.id)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_network = resultSet[1]
|
|
|
|
isolated_network.update(self.apiclient, guestvmcidr="10.1.1.0/26")
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_vm_create_after_reservation(self):
|
|
# steps
|
|
# 1. create vm in persistent isolated network with ip in guestvmcidr
|
|
# 2. update guestvmcidr
|
|
# 3. create another VM
|
|
#
|
|
# validation
|
|
# 1. guest vm cidr should be successfully updated with correct value
|
|
# 2. existing guest vm ip should not be changed after reservation
|
|
# 3. newly created VM should get ip in guestvmcidr
|
|
|
|
networkOffering = self.isolated_persistent_network_offering
|
|
subnet = "10.1."+str(random.randrange(1,254))
|
|
gateway = subnet + ".1"
|
|
isolated_persistent_network = None
|
|
resultSet = createIsolatedNetwork(self, networkOffering.id, gateway=gateway)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_persistent_network = resultSet[1]
|
|
guest_vm_cidr = subnet +".0/29"
|
|
virtual_machine_1 = None
|
|
try:
|
|
virtual_machine_1 = VirtualMachine.create(self.apiclient,
|
|
self.testData["virtual_machine"],
|
|
networkids=isolated_persistent_network.id,
|
|
serviceofferingid=self.service_offering.id,
|
|
accountid=self.account.name,
|
|
domainid=self.domain.id,
|
|
ipaddress=subnet+".3"
|
|
)
|
|
except Exception as e:
|
|
self.fail("VM creation fails in network: %s" % e)
|
|
|
|
update_response = Network.update(isolated_persistent_network, self.apiclient, id=isolated_persistent_network.id, guestvmcidr=guest_vm_cidr)
|
|
self.assertEqual(guest_vm_cidr, update_response.cidr, "cidr in response is not as expected")
|
|
vm_list = VirtualMachine.list(self.apiclient,
|
|
id=virtual_machine_1.id)
|
|
self.assertEqual(isinstance(vm_list, list),
|
|
True,
|
|
"VM list response in not a valid list")
|
|
self.assertEqual(vm_list[0].nic[0].ipaddress,
|
|
virtual_machine_1.ipaddress,
|
|
"VM IP should not change after reservation")
|
|
try:
|
|
virtual_machine_2 = VirtualMachine.create(self.apiclient,
|
|
self.testData["virtual_machine"],
|
|
networkids=isolated_persistent_network.id,
|
|
serviceofferingid=self.service_offering.id,
|
|
accountid=self.account.name,
|
|
domainid=self.domain.id
|
|
)
|
|
if netaddr.IPAddress(virtual_machine_2.ipaddress) not in netaddr.IPNetwork(guest_vm_cidr):
|
|
self.fail("Newly created VM doesn't get IP from reserverd CIDR")
|
|
except Exception as e:
|
|
self.skipTest("VM creation fails, cannot validate the condition: %s" % e)
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_reservation_after_router_restart(self):
|
|
# steps
|
|
# 1. update guestvmcidr of persistent isolated network
|
|
# 2. reboot router
|
|
#
|
|
# validation
|
|
# 1. guest vm cidr should be successfully updated with correct value
|
|
# 2. network cidr should remain same after router restart
|
|
networkOffering = self.isolated_persistent_network_offering
|
|
subnet = "10.1."+str(random.randrange(1,254))
|
|
gateway = subnet + ".1"
|
|
isolated_persistent_network = None
|
|
resultSet = createIsolatedNetwork(self, networkOffering.id, gateway=gateway)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_persistent_network = resultSet[1]
|
|
|
|
response = verifyNetworkState(self.apiclient, isolated_persistent_network.id,\
|
|
"implemented")
|
|
exceptionOccurred = response[0]
|
|
isNetworkInDesiredState = response[1]
|
|
exceptionMessage = response[2]
|
|
|
|
if (exceptionOccurred or (not isNetworkInDesiredState)):
|
|
self.fail(exceptionMessage)
|
|
guest_vm_cidr = subnet +".0/29"
|
|
|
|
update_response = Network.update(isolated_persistent_network, self.apiclient, id=isolated_persistent_network.id, guestvmcidr=guest_vm_cidr)
|
|
self.assertEqual(guest_vm_cidr, update_response.cidr, "cidr in response is not as expected")
|
|
|
|
routers = Router.list(self.apiclient,
|
|
networkid=isolated_persistent_network.id,
|
|
listall=True)
|
|
self.assertEqual(
|
|
isinstance(routers, list),
|
|
True,
|
|
"list router should return valid response"
|
|
)
|
|
if not routers:
|
|
self.skipTest("Router list should not be empty, skipping test")
|
|
|
|
Router.reboot(self.apiclient, routers[0].id)
|
|
networks = Network.list(self.apiclient, id=isolated_persistent_network.id)
|
|
self.assertEqual(
|
|
isinstance(networks, list),
|
|
True,
|
|
"list Networks should return valid response"
|
|
)
|
|
self.assertEqual(networks[0].cidr, guest_vm_cidr, "guestvmcidr should match after router reboot")
|
|
return
|
|
|
|
@attr(tags=["advanced"], required_hardware="false")
|
|
def test_vm_create_outside_cidr_after_reservation(self):
|
|
# steps
|
|
# 1. update guestvmcidr of persistent isolated network
|
|
# 2. create another VM with ip outside guestvmcidr
|
|
#
|
|
# validation
|
|
# 1. guest vm cidr should be successfully updated with correct value
|
|
# 2 newly created VM should not be created and result in exception
|
|
networkOffering = self.isolated_persistent_network_offering
|
|
subnet = "10.1."+str(random.randrange(1,254))
|
|
gateway = subnet + ".1"
|
|
isolated_persistent_network = None
|
|
resultSet = createIsolatedNetwork(self, networkOffering.id, gateway=gateway)
|
|
if resultSet[0] == FAIL:
|
|
self.fail("Failed to create isolated network")
|
|
else:
|
|
isolated_persistent_network = resultSet[1]
|
|
guest_vm_cidr = subnet +".0/29"
|
|
update_response = Network.update(isolated_persistent_network, self.apiclient, id=isolated_persistent_network.id, guestvmcidr=guest_vm_cidr)
|
|
self.assertEqual(guest_vm_cidr, update_response.cidr, "cidr in response is not as expected")
|
|
with self.assertRaises(Exception):
|
|
VirtualMachine.create(self.apiclient,
|
|
self.testData["virtual_machine"],
|
|
networkids=isolated_persistent_network.id,
|
|
serviceofferingid=self.service_offering.id,
|
|
accountid=self.account.name,
|
|
domainid=self.domain.id,
|
|
ipaddress="10.1.1.9"
|
|
)
|
|
return
|