def test_09_update_network_offering_isolated_network(self):
"""Test Update network offering for isolated Networks
with Nuage VSP SDN plugin
"""
# Create an Isolated Network with Nuage VSP Isolated Network
# offering specifying Services which don't need a VR.
# Update the network offering of this network to one that
# needs a VR, check that a VR is spawn
# After that update network to previous offering
# Check that VR is destroyed and removed.
self.debug("+++Create an Isolated network with a network "
"offering which has only services without VR")
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "isolated.com"
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering which has only service without VR...")
network_offering = self.create_NetworkOffering(
self.test_data["nuagevsp"]
["isolated_network_offering_without_vr"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
self.validate_Network(network_1, state="Allocated")
self.debug("+++Deploy VM in the created Isolated network "
"with only services without VR")
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
with self.assertRaises(Exception):
self.get_Router(network_1)
self.debug("+++Verified no VR is spawned for this network ")
self.debug("+++ Upgrade offering of created Isolated network with "
"a dns offering which spins a VR")
self.upgrade_Network(self.test_data["nuagevsp"][
"isolated_network_offering"],
network_1)
vr = self.get_Router(network_1)
self.check_Router_state(vr, state="Running")
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_router(vr)
self.debug("+++ Upgrade offering of created Isolated network with "
"an offering which removes the VR...")
self.upgrade_Network(self.test_data["nuagevsp"][
"isolated_network_offering_without_vr"],
network_1)
with self.assertRaises(Exception):
self.get_Router(network_1)
self.debug("+++Verified no VR is spawned for this network ")
def test_02_Isolated_Network(self):
""" Verify InternalDns on Isolated Network with ping by hostname
"""
# Validate the following
# 1. Create an Isolated network - network1 (10.1.1.1/24) by using DNS
# network offering.
# 2. Deploy vm1 in network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Deploy VM2 in network1.
# 6. Verify end to end by pinging with hostname
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = ISOLATED_DOMAIN_NAME
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["isolated_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME,
network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME,
nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
self.test_data["virtual_machine"]["displayname"] = "vm2"
self.test_data["virtual_machine"]["name"] = "vm2"
vm_2 = self.create_VM(network_1)
self.test_data["virtual_machine"]["displayname"] = "vm1"
self.test_data["virtual_machine"]["name"] = "vm1"
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME,
nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
public_ip_1 = self.acquire_PublicIPAddress(network_1)
self.create_and_verify_fw(vm_1, public_ip_1, network_1)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, ISOLATED_DOMAIN_NAME)
def test_04_Update_Network_with_Domain(self):
""" Verify update NetworkDomain for InternalDns on Isolated Network
"""
# Validate the following
# 1. Create an Isolated network - network1 (10.1.1.1/24) by using DNS
# network offering.
# 2. Deploy vm1 in network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Update Network domain and verify it is properly updated
# update Network Domain at zone level
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = ISOLATED_DOMAIN_NAME
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["isolated_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME,
nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
update_response = Network.update(network_1,
self.apiclient,
id=network_1.id,
networkdomain=UPDATED_DOMAIN_NAME,
changecidr=False)
completeoutput = str(update_response).strip('[]')
self.debug("network update response is " + completeoutput)
self.assertEqual(UPDATED_DOMAIN_NAME, update_response.networkdomain,
"Network Domain is not updated as expected")
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, UPDATED_DOMAIN_NAME,
network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, UPDATED_DOMAIN_NAME,
nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
def test_02_Isolated_Network(self):
""" Verify InternalDns on Isolated Network with ping by hostname
"""
# Validate the following
# 1. Create an Isolated network - network1 (10.1.1.1/24) by using DNS
# network offering.
# 2. Deploy vm1 in network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Deploy VM2 in network1.
# 6. Verify end to end by pinging with hostname
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = ISOLATED_DOMAIN_NAME
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["isolated_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME, network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
self.test_data["virtual_machine"]["displayname"] = "vm2"
self.test_data["virtual_machine"]["name"] = "vm2"
vm_2 = self.create_VM(network_1)
self.test_data["virtual_machine"]["displayname"] = "vm1"
self.test_data["virtual_machine"]["name"] = "vm1"
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
public_ip_1 = self.acquire_PublicIPAddress(network_1)
self.create_and_verify_fw(vm_1, public_ip_1, network_1)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, ISOLATED_DOMAIN_NAME)
def test_09_update_network_offering_isolated_network(self):
"""Test Update network offering for isolated Networks
with Nuage VSP SDN plugin
"""
# Create an Isolated Network with Nuage VSP Isolated Network
# offering specifying Services which don't need a VR.
# Update the network offering of this network to one that
# needs a VR, check that a VR is spawn
# After that update network to previous offering
# Check that VR is destroyed and removed.
self.debug("+++Create an Isolated network with a network "
"offering which has only services without VR")
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "isolated.com"
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering which has only service without VR...")
network_offering = self.create_NetworkOffering(
self.test_data["nuagevsp"]["isolated_network_offering_without_vr"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
self.validate_Network(network_1, state="Allocated")
self.debug("+++Deploy VM in the created Isolated network "
"with only services without VR")
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
with self.assertRaises(Exception):
self.get_Router(network_1)
self.debug("+++Verified no VR is spawned for this network ")
self.debug("+++ Upgrade offering of created Isolated network with "
"a dns offering which spins a VR")
self.upgrade_Network(
self.test_data["nuagevsp"]["isolated_network_offering"], network_1)
vr = self.get_Router(network_1)
self.check_Router_state(vr, state="Running")
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_router(vr)
self.debug("+++ Upgrade offering of created Isolated network with "
"an offering which removes the VR...")
self.upgrade_Network(
self.test_data["nuagevsp"]["isolated_network_offering_without_vr"],
network_1)
with self.assertRaises(Exception):
self.get_Router(network_1)
self.debug("+++Verified no VR is spawned for this network ")
def test_03_Update_Network_with_Domain(self):
""" Verify update NetworkDomain for InternalDns on Isolated Network
"""
# Validate the following
# 1. Create an Isolated network - network1 (10.1.1.1/24) by using DNS
# network offering.
# 2. Deploy vm1 in network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Update Network domain and verify it is properly updated
# update Network Domain at zone level
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "isolated.com"
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["isolated_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, "isolated.com", nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
update_response = Network.update(
network_1, self.apiclient, id=network_1.id,
networkdomain="update.com", changecidr=False)
completeoutput = str(update_response).strip('[]')
self.debug("network update response is " + completeoutput)
self.assertEqual("update.com", update_response.networkdomain,
"Network Domain is not updated as expected"
)
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "update.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, "update.com", nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
def tearDownClass(cls):
try:
zoneList = Zone.list(cls.apiclient, id=cls.zone.id)
if zoneList[0].allocationstate == DISABLED:
cmd = updateZone.updateZoneCmd()
cmd.id = zoneList[0].id
cmd.allocationstate = ENABLED
cls.apiclient.updateZone(cmd)
cleanup_resources(cls.apiclient, cls._cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
def test_06_VPC_Network_With_InternalDns(self):
""" Verify InternalDns on VPC Network
"""
# Validate the following
# 1. Create a VPC and tier network by using DNS network offering.
# 2. Deploy vm1 in tier network.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = VPC_DOMAIN_NAME
self.apiclient.updateZone(cmd)
vpc_off = self.create_VpcOffering(self.dnsdata["vpc_offering"])
self.validate_VpcOffering(vpc_off, state="Enabled")
vpc = self.create_Vpc(vpc_off, cidr='10.1.0.0/16', cleanup=False)
self.debug("Creating Nuage Vsp VPC Network offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["vpc_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering,
gateway='10.1.1.1',
vpc=vpc)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME,
network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic,
True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
def test_05_VPC_Network_With_InternalDns(self):
""" Verify InternalDns on VPC Network
"""
# Validate the following
# 1. Create a VPC and tier network by using DNS network offering.
# 2. Deploy vm1 in tier network.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "vpc.com"
self.apiclient.updateZone(cmd)
vpc_off = self.create_VpcOffering(self.dnsdata["vpc_offering"])
self.validate_VpcOffering(vpc_off, state="Enabled")
vpc = self.create_Vpc(vpc_off, cidr='10.1.0.0/16', cleanup=False)
self.debug("Creating Nuage Vsp VPC Network offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["vpc_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(
network_offering, gateway='10.1.1.1', vpc=vpc)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
def test_01_Isolated_Network_with_zone(self):
""" Verify InternalDns on Isolated Network
"""
# Validate the following
# 1. Create an Isolated network - network1 (10.1.1.1/24) by using DNS
# network offering.
# 2. Deploy vm1 in network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# update Network Domain at zone level
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = ISOLATED_DOMAIN_NAME
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["isolated_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME,
network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME,
nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
def test_01_Isolated_Network_with_zone(self):
""" Verify InternalDns on Isolated Network
"""
# Validate the following
# 1. Create an Isolated network - network1 (10.1.1.1/24) by using DNS
# network offering.
# 2. Deploy vm1 in network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# update Network Domain at zone level
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "isolated.com"
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["isolated_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, "isolated.com", nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
def test_05_Update_Network_with_Domain(self):
""" Verify update NetworkDomain for InternalDns on Isolated Network
with ping VM
"""
# Validate the following
# 1. Create an Isolated network - network1 (10.1.1.1/24) by using DNS
# network offering.
# 2. Deploy vm1 in network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Update Network domain and verify it is properly updated
# update Network Domain at zone level
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = ISOLATED_DOMAIN_NAME
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["isolated_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME,
network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME,
nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
update_response = Network.update(network_1,
self.apiclient,
id=network_1.id,
networkdomain=UPDATED_DOMAIN_NAME,
changecidr=False)
completeoutput = str(update_response).strip('[]')
self.debug("network update response is " + completeoutput)
self.assertEqual(UPDATED_DOMAIN_NAME, update_response.networkdomain,
"Network Domain is not updated as expected")
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, UPDATED_DOMAIN_NAME,
network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, UPDATED_DOMAIN_NAME,
nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
# stop and start VM to get new DHCP option
try:
vm_1.stop(self.apiclient)
except Exception as e:
self.fail("Failed to stop the virtual instances, %s" % e)
self.test_data["virtual_machine"]["displayname"] = "vm2"
self.test_data["virtual_machine"]["name"] = "vm2"
vm_2 = self.create_VM(network_1)
self.test_data["virtual_machine"]["displayname"] = "vm1"
self.test_data["virtual_machine"]["name"] = "vm1"
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, UPDATED_DOMAIN_NAME,
nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
try:
vm_1.start(self.apiclient)
except Exception as e:
self.fail("Failed to start the virtual instances, %s" % e)
public_ip_1 = self.acquire_PublicIPAddress(network_1)
self.create_and_verify_fw(vm_1, public_ip_1, network_1)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, UPDATED_DOMAIN_NAME)
def test_05_Update_Network_with_Domain(self):
""" Verify update NetworkDomain for InternalDns on Isolated Network
with ping VM
"""
# Validate the following
# 1. Create an Isolated network - network1 (10.1.1.1/24) by using DNS
# network offering.
# 2. Deploy vm1 in network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Update Network domain and verify it is properly updated
# update Network Domain at zone level
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = ISOLATED_DOMAIN_NAME
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["isolated_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, ISOLATED_DOMAIN_NAME, network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
update_response = Network.update(
network_1, self.apiclient, id=network_1.id,
networkdomain=UPDATED_DOMAIN_NAME, changecidr=False)
completeoutput = str(update_response).strip('[]')
self.debug("network update response is " + completeoutput)
self.assertEqual(UPDATED_DOMAIN_NAME, update_response.networkdomain,
"Network Domain is not updated as expected"
)
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, UPDATED_DOMAIN_NAME, network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, UPDATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
# stop and start VM to get new DHCP option
try:
vm_1.stop(self.apiclient)
except Exception as e:
self.fail("Failed to stop the virtual instances, %s" % e)
self.test_data["virtual_machine"]["displayname"] = "vm2"
self.test_data["virtual_machine"]["name"] = "vm2"
vm_2 = self.create_VM(network_1)
self.test_data["virtual_machine"]["displayname"] = "vm1"
self.test_data["virtual_machine"]["name"] = "vm1"
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, UPDATED_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
try:
vm_1.start(self.apiclient)
except Exception as e:
self.fail("Failed to start the virtual instances, %s" % e)
public_ip_1 = self.acquire_PublicIPAddress(network_1)
self.create_and_verify_fw(vm_1, public_ip_1, network_1)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, UPDATED_DOMAIN_NAME)
def test_08_VPC_Network_Restarts_With_InternalDns(self):
""" Verify InternalDns on VPC Network with restarts and ping by
hostname
"""
# Validate the following
# 1. Create a VPC and Tier network by using DNS network offering.
# 2. Deploy vm1 in Tier network network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Deploy Vm2.
# 6. Verify end to end by pinging with hostname while restarting
# VPC and Tier without and with cleanup.
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = VPC_DOMAIN_NAME
self.apiclient.updateZone(cmd)
vpc_off = self.create_VpcOffering(self.dnsdata["vpc_offering"])
self.validate_VpcOffering(vpc_off, state="Enabled")
vpc = self.create_Vpc(vpc_off, cidr='10.1.0.0/16', cleanup=False)
self.debug("Creating Nuage Vsp VPC Network offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["vpc_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(
network_offering, gateway='10.1.1.1', vpc=vpc)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
self.test_data["virtual_machine"]["displayname"] = "vm2"
self.test_data["virtual_machine"]["name"] = "vm2"
vm_2 = self.create_VM(network_1)
self.test_data["virtual_machine"]["displayname"] = "vm1"
self.test_data["virtual_machine"]["name"] = "vm1"
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
public_ip_1 = self.acquire_PublicIPAddress(network_1, vpc)
self.create_StaticNatRule_For_VM(vm_1, public_ip_1, network_1)
# Adding Network ACL rule in the Public tier
self.debug("Adding Network ACL rule to make the created NAT rule "
"(SSH) accessible...")
public_ssh_rule = self.create_NetworkAclRule(
self.test_data["ingress_rule"], network=network_1)
# VSD verification
self.verify_vsd_firewall_rule(public_ssh_rule)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
# Restarting VPC network (cleanup = false)
self.debug("Restarting the created VPC network without cleanup...")
Network.restart(network_1, self.api_client, cleanup=False)
self.validate_Network(network_1, state="Implemented")
vr = self.get_Router(network_1)
self.check_Router_state(vr, state="Running")
self.check_VM_state(vm_1, state="Running")
self.check_VM_state(vm_2, state="Running")
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_router(vr)
self.verify_vsd_vm(vm_1)
self.verify_vsd_vm(vm_2)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
# Restarting VPC network (cleanup = true)
self.debug("Restarting the created VPC network with cleanup...")
Network.restart(network_1, self.api_client, cleanup=True)
self.validate_Network(network_1, state="Implemented")
vr = self.get_Router(network_1)
self.check_Router_state(vr, state="Running")
self.check_VM_state(vm_1, state="Running")
self.check_VM_state(vm_2, state="Running")
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_router(vr)
self.verify_vsd_vm(vm_1)
self.verify_vsd_vm(vm_2)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
# Restarting VPC (cleanup = false)
self.debug("Restarting the VPC without cleanup...")
self.restart_Vpc(vpc, cleanup=False)
self.validate_Network(network_1, state="Implemented")
vr = self.get_Router(network_1)
self.check_Router_state(vr, state="Running")
self.check_VM_state(vm_1, state="Running")
self.check_VM_state(vm_2, state="Running")
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_router(vr)
self.verify_vsd_vm(vm_1)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
# Restarting VPC (cleanup = true)
self.debug("Restarting the VPC with cleanup...")
self.restart_Vpc(vpc, cleanup=True)
self.validate_Network(network_1, state="Implemented")
vr = self.get_Router(network_1)
self.check_Router_state(vr, state="Running")
self.check_VM_state(vm_1, state="Running")
self.check_VM_state(vm_2, state="Running")
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_router(vr)
self.verify_vsd_vm(vm_1)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
def test_06_VPC_Network_With_InternalDns(self):
""" Verify InternalDns on VPC Network by ping with hostname
"""
# Validate the following
# 1. Create a VPC and Tier network by using DNS network offering.
# 2. Deploy vm1 in Tier network network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Deploy Vm2.
# 6. Verify end to end by pinging with hostname
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "vpc.com"
self.apiclient.updateZone(cmd)
vpc_off = self.create_VpcOffering(self.dnsdata["vpc_offering"])
self.validate_VpcOffering(vpc_off, state="Enabled")
vpc = self.create_Vpc(vpc_off, cidr='10.1.0.0/16', cleanup=False)
self.debug("Creating Nuage Vsp VPC Network offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["vpc_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering,
gateway='10.1.1.1',
vpc=vpc)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
self.test_data["virtual_machine"]["displayname"] = "vm2"
self.test_data["virtual_machine"]["name"] = "vm2"
vm_2 = self.create_VM(network_1)
self.test_data["virtual_machine"]["displayname"] = "vm1"
self.test_data["virtual_machine"]["name"] = "vm1"
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
public_ip_1 = self.acquire_PublicIPAddress(network_1, vpc)
self.create_StaticNatRule_For_VM(vm_1, public_ip_1, network_1)
# Adding Network ACL rule in the Public tier
self.debug("Adding Network ACL rule to make the created NAT rule "
"(SSH) accessible...")
public_ssh_rule = self.create_NetworkAclRule(
self.test_data["ingress_rule"], network=network_1)
# VSD verification
self.verify_vsd_firewall_rule(public_ssh_rule)
vm_public_ip = public_ip_1.ipaddress.ipaddress
try:
vm_1.ssh_ip = vm_public_ip
vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_1.username = self.test_data["virtual_machine"]["username"]
vm_1.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_1.ssh_ip, vm_1.password))
ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
cmd = 'ping -c 2 vm2'
self.debug("ping vm2 by hostname with command: " + cmd)
outputlist = ssh.execute(cmd)
self.debug("command is executed properly " + cmd)
completeoutput = str(outputlist).strip('[]')
self.debug("complete output is " + completeoutput)
expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
for item in expectedlist:
if item in completeoutput:
self.debug("excepted value found in vm: " + item)
else:
self.fail("excepted value not found in vm: " + item)
def test_04_Update_Network_with_Domain(self):
""" Verify update NetworkDomain for InternalDns on Isolated Network
with ping VM
"""
# Validate the following
# 1. Create an Isolated network - network1 (10.1.1.1/24) by using DNS
# network offering.
# 2. Deploy vm1 in network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Update Network domain and verify it is properly updated
# update Network Domain at zone level
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "isolated.com"
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["isolated_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", nic,
True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
update_response = Network.update(network_1,
self.apiclient,
id=network_1.id,
networkdomain="update.com",
changecidr=False)
completeoutput = str(update_response).strip('[]')
self.debug("network update response is " + completeoutput)
self.assertEqual("update.com", update_response.networkdomain,
"Network Domain is not updated as expected")
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "update.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "update.com", nic,
True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
# stop and start VM to get new DHCP option
try:
vm_1.stop(self.apiclient)
except Exception as e:
self.fail("Failed to stop the virtual instances, %s" % e)
try:
vm_1.start(self.apiclient)
except Exception as e:
self.fail("Failed to start the virtual instances, %s" % e)
self.test_data["virtual_machine"]["displayname"] = "vm2"
self.test_data["virtual_machine"]["name"] = "vm2"
vm_2 = self.create_VM(network_1)
self.test_data["virtual_machine"]["displayname"] = "vm1"
self.test_data["virtual_machine"]["name"] = "vm1"
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "update.com", nic,
True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
public_ip_1 = self.acquire_PublicIPAddress(network_1)
self.create_and_verify_fw(vm_1, public_ip_1, network_1)
vm_public_ip = public_ip_1.ipaddress.ipaddress
try:
vm_1.ssh_ip = vm_public_ip
vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_1.username = self.test_data["virtual_machine"]["username"]
vm_1.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_1.ssh_ip, vm_1.password))
ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
except Exception as e:
self.fail("SSH into VM failed with exception: %s " % e)
cmd = 'ping -c 2 vm2'
self.debug("ping vm2 by hostname with command: " + cmd)
outputlist = ssh.execute(cmd)
self.debug("command is executed properly " + cmd)
completeoutput = str(outputlist).strip('[]')
self.debug("complete output is " + completeoutput)
expectedlist = ['2 received', 'vm2.update.com', vm_2.ipaddress]
for item in expectedlist:
if item in completeoutput:
self.debug("excepted value found in vm: " + item)
else:
self.fail("excepted value not found in vm: " + item)
def test_02_Isolated_Network(self):
""" Verify InternalDns on Isolated Network with ping by hostname
"""
# Validate the following
# 1. Create an Isolated network - network1 (10.1.1.1/24) by using DNS
# network offering.
# 2. Deploy vm1 in network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Deploy VM2 in network1.
# 6. Verify end to end by pinging with hostname
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "isolated.com"
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["isolated_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", nic,
True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
self.test_data["virtual_machine"]["displayname"] = "vm2"
self.test_data["virtual_machine"]["name"] = "vm2"
vm_2 = self.create_VM(network_1)
self.test_data["virtual_machine"]["displayname"] = "vm1"
self.test_data["virtual_machine"]["name"] = "vm1"
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", nic,
True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
public_ip_1 = self.acquire_PublicIPAddress(network_1)
self.create_and_verify_fw(vm_1, public_ip_1, network_1)
vm_public_ip = public_ip_1.ipaddress.ipaddress
try:
vm_1.ssh_ip = vm_public_ip
vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_1.username = self.test_data["virtual_machine"]["username"]
vm_1.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_1.ssh_ip, vm_1.password))
ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
cmd = 'ping -c 2 vm2'
self.debug("ping vm2 by hostname with command: " + cmd)
outputlist = ssh.execute(cmd)
self.debug("command is executed properly " + cmd)
completeoutput = str(outputlist).strip('[]')
self.debug("complete output is " + completeoutput)
expectedlist = ['2 received', 'vm2.isolated.com', vm_2.ipaddress]
for item in expectedlist:
if item in completeoutput:
self.debug("excepted value found in vm: " + item)
else:
self.fail("excepted value not found in vm: " + item)
def test_01_disable_enable_zone(self):
"""disable enable zone
1. Disable zone and verify following things:
For admin user:
1. Should be create to start/stop exsiting vms
2. Should be create to deploy new vm, snapshot,volume,
template,iso in the same zone
For Non-admin user:
1. Should be create to start/stop exsiting vms
2. Should not be create to deploy new vm, snapshot,volume,
template,iso in the same zone
2. Enable the above disabled zone and verify that:
-All users should be create to deploy new vm,
snapshot,volume,template,iso in the same zone
3. Try to delete the zone and it should fail with error message:
-"The zone is not deletable because there are
servers running in this zone"
"""
# Step 1
vm_user = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id
)
vm_root = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id
)
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.allocationstate = DISABLED
self.apiclient.updateZone(cmd)
zoneList = Zone.list(self.apiclient, id=self.zone.id)
self.assertEqual(zoneList[0].allocationstate,
DISABLED,
"Check if the zone is in disabled state"
)
# Both user and admin vms shoul be running
self.assertEqual(vm_user.state,
RUNNING,
"Verify that the user vm is running")
self.assertEqual(vm_root.state,
RUNNING,
"Verify that the admin vm is running")
vm_root.stop(self.apiclient)
vm_user.stop(self.apiclient)
root_state = self.dbclient.execute(
"select state from vm_instance where name='%s'" %
vm_root.name)[0][0]
user_state = self.dbclient.execute(
"select state from vm_instance where name='%s'" %
vm_user.name)[0][0]
self.assertEqual(root_state,
STOPPED,
"verify that vm is Stopped")
self.assertEqual(user_state,
STOPPED,
"verify that vm is stopped")
root_volume = list_volumes(
self.userapiclient,
virtualmachineid=vm_root.id,
type='ROOT',
listall=True
)
snap = Snapshot.create(
self.apiclient,
root_volume[0].id)
self.assertNotEqual(snap,
None,
"Verify that admin should be \
able to create snapshot")
snapshots = list_snapshots(
self.apiclient,
volumeid=root_volume[0].id,
listall=True)
template_from_snapshot = Template.create_from_snapshot(
self.apiclient,
snapshots[0],
self.testdata["privatetemplate"])
self.assertNotEqual(
template_from_snapshot,
None,
"Verify that admin should be able to create template"
)
builtin_info = get_builtin_template_info(self.apiclient, self.zone.id)
self.testdata["privatetemplate"]["url"] = builtin_info[0]
self.testdata["privatetemplate"]["hypervisor"] = builtin_info[1]
self.testdata["privatetemplate"]["format"] = builtin_info[2]
template_regis = Template.register(
self.apiclient,
self.testdata["privatetemplate"],
zoneid=self.zone.id)
self.assertNotEqual(
template_regis,
None,
"Check if template gets created"
)
self.assertNotEqual(
template_from_snapshot,
None,
"Check if template gets created"
)
data_volume = Volume.create(
self.apiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id
)
self.assertNotEqual(
data_volume,
None,
"Check if volume gets created"
)
ISO = Iso.create(
self.apiclient,
self.testdata["iso2"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
)
self.assertNotEqual(
ISO,
None,
"Check if volume gets created"
)
# non-admin user should fail to create vm, snap, temp etc
with self.assertRaises(Exception):
VirtualMachine.create(self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id
)
root_volume = list_volumes(
self.userapiclient,
virtualmachineid=vm_user.id,
type='ROOT',
listall=True
)
with self.assertRaises(Exception):
snap = Snapshot.create(
self.userapiclient,
root_volume[0].id)
with self.assertRaises(Exception):
Template.register(
self.userapiclient,
self.testdata["privatetemplate"],
zoneid=self.zone.id)
with self.assertRaises(Exception):
Volume.create(
self.userapiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id
)
with self.assertRaises(Exception):
ISO = Iso.create(
self.userapiclient,
self.testdata["iso2"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
)
# Step 2
cmd.allocationstate = ENABLED
self.apiclient.updateZone(cmd)
# After enabling the zone all users should be able to add new VM,
# volume, template and iso
root_vm_new = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id
)
self.assertNotEqual(root_vm_new,
None,
"Verify that admin should create new VM")
snap = Snapshot.create(
self.apiclient,
root_volume[0].id)
self.assertNotEqual(snap,
None,
"Verify that admin should snashot")
snapshots = list_snapshots(
self.apiclient,
volumeid=root_volume[0].id,
listall=True)
template_from_snapshot = Template.create_from_snapshot(
self.apiclient,
snapshots[0],
self.testdata["privatetemplate"])
self.assertNotEqual(
template_from_snapshot,
None,
"Check if template gets created"
)
template_regis = Template.register(
self.apiclient,
self.testdata["privatetemplate"],
zoneid=self.zone.id)
self.assertNotEqual(
template_regis,
None,
"Check if template gets created"
)
self.assertNotEqual(
template_from_snapshot,
None,
"Check if template gets created"
)
data_volume = Volume.create(
self.apiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id
)
self.assertNotEqual(
data_volume,
None,
"Check if volume gets created"
)
ISO = Iso.create(
self.apiclient,
self.testdata["iso2"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
)
self.assertNotEqual(
ISO,
None,
"Check if volume gets created"
)
root_vm_new.delete(self.apiclient)
# Non root user
user_vm_new = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id
)
self.assertNotEqual(user_vm_new,
None,
"Verify that admin should create new VM")
snap = Snapshot.create(
self.userapiclient,
root_volume[0].id)
self.assertNotEqual(snap,
None,
"Verify that admin should snashot")
snapshots = list_snapshots(
self.userapiclient,
volumeid=root_volume[0].id,
listall=True)
template_regis = Template.register(
self.userapiclient,
self.testdata["privatetemplate"],
zoneid=self.zone.id)
self.assertNotEqual(
template_regis,
None,
"Check if template gets created"
)
self.assertNotEqual(
template_from_snapshot,
None,
"Check if template gets created"
)
data_volume = Volume.create(
self.userapiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id
)
self.assertNotEqual(
data_volume,
None,
"Check if volume gets created"
)
ISO = Iso.create(
self.userapiclient,
self.testdata["iso2"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
)
self.assertNotEqual(
ISO,
None,
"Check if volume gets created"
)
user_vm_new.delete(self.apiclient)
# Step 3
# Deletion of zone should fail if vm,volume is present on the zone
with self.assertRaises(Exception):
self.zone.delete(self.apiclient)
return
def test_02_nuage_mngd_subnets_vpc(self):
"""Test Nuage VSP Managed Subnets for vpc and tier networks
"""
# 1. Create multiple L3DomainTemplate with Zone and Subnet on VSP
# Create Ingress & Egress ACL Top & Bottom Templates
# Add ACL rules to allow intra-subnet traffic
# Instiantiate these L3Domains and store its Subnet VSD ID
# 2. Create a vpc network offering and create a VPC
# create vpc tier network offerings with and without VirtualRouter
# 3. Create vpc tier networks specifying above offerings and
# specifying the stored Subnet ID's of VSP
# 4. Verify ACL rules and connectivity via deploying VM's ,
# Enabling staticNAT, applying firewall and egress rules
# 5. Verify negative tests like uniqueness of vsd subnet
# Create all items on vsd required for this test
enterprise = self.fetch_by_externalID(self._session.user.enterprises,
self.domain)
domain_template = self.create_vsd_domain_template(enterprise)
self.create_vsd_default_acls(domain_template)
domain1 = self.create_vsd_domain(domain_template, enterprise,
"L3DomainToBeConsumedByACS")
zone1 = self.create_vsd_zone(domain1, "ZoneToBeConsumedByACS")
subnet1 = self.create_vsd_subnet(zone1, "SubnetToBeConsumedByACS",
"10.1.0.1/24")
subnet2 = self.create_vsd_subnet(zone1, "2ndSubnetToBeConsumedByACS",
"10.1.128.1/24")
domain2 = self.create_vsd_domain(domain_template, enterprise,
"2ndL3DomainToBeConsumedByACS")
zone2 = self.create_vsd_zone(domain2, "2ndZoneToBeConsumedByACS")
subnet3 = self.create_vsd_subnet(zone2, "3rdSubnetToBeConsumedByACS",
"10.2.128.1/24")
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "vpc.com"
self.api_client.updateZone(cmd)
self.debug("Creating a VPC with Static NAT service provider as "
"VpcVirtualRouter")
vpc = self.create_Vpc(self.nuage_vpc_offering, cidr='10.1.0.0/16')
self.validate_Vpc(vpc, state="Enabled")
acl_list = self.create_NetworkAclList(
name="acl", description="acl", vpc=vpc)
self.create_NetworkAclRule(
self.test_data["ingress_rule"], acl_list=acl_list)
self.create_NetworkAclRule(
self.test_data["icmprule"], acl_list=acl_list)
self.debug("Creating another VPC with Static NAT service provider "
"as VpcVirtualRouter")
vpc2 = self.create_Vpc(self.nuage_vpc_offering, cidr='10.2.0.0/16')
self.validate_Vpc(vpc2, state="Enabled")
acl_list2 = self.create_NetworkAclList(
name="acl", description="acl", vpc=vpc2)
self.create_NetworkAclRule(
self.test_data["ingress_rule"], acl_list=acl_list2)
self.create_NetworkAclRule(
self.test_data["icmprule"], acl_list=acl_list2)
self.debug("Creating an unmanaged VPC tier network with Static NAT")
vpc2_tier_unmngd = self.create_Network(self.nuage_vpc_network_offering,
gateway='10.2.0.1',
vpc=vpc2,
acl_list=acl_list2)
self.validate_Network(vpc2_tier_unmngd, state="Implemented")
# VPC Tier Network creation should fail as VPC is unmanaged already
with self.assertRaises(Exception):
self.create_Network(self.nuage_vpc_network_offering,
gateway='10.2.128.1',
vpc=vpc2,
acl_list=acl_list2,
externalid=subnet3.id)
vpc2_tier_unmngd.delete(self.api_client)
vpc2.delete(self.api_client)
# VPC tier network creation fails when cidr does not match on VSD
with self.assertRaises(Exception):
self.create_Network(self.nuage_vpc_network_offering,
gateway='10.1.1.1',
vpc=vpc,
acl_list=acl_list,
externalid=subnet1.id)
for i in range(1, 3):
self.debug("Creating a mngd VPC tier with Static NAT service")
vpc_tier = self.create_Network(self.nuage_vpc_network_offering,
gateway='10.1.0.1',
vpc=vpc,
acl_list=acl_list,
externalid=subnet1.id,
cleanup=False)
self.validate_Network(vpc_tier, state="Implemented")
self.debug("Creating 2nd VPC tier network with Static NAT service")
# VPC 2nd tier creation fails when cidr doesn't match on VSD
with self.assertRaises(Exception):
self.create_Network(self.nuage_vpc_network_offering,
gateway='10.1.129.1',
vpc=vpc,
acl_list=acl_list,
externalid=subnet2.id)
vpc_2ndtier = self.create_Network(self.nuage_vpc_network_offering,
gateway='10.1.128.1',
vpc=vpc,
acl_list=acl_list,
externalid=subnet2.id,
cleanup=False)
self.validate_Network(vpc_2ndtier, state="Implemented")
vpc_vr = self.get_Router(vpc_tier)
self.check_Router_state(vpc_vr, state="Running")
# VSD verification
self.verify_vsd_network_not_present(vpc_tier, vpc)
self.verify_vsd_network_not_present(vpc_2ndtier, vpc)
# On ACS create VPCTier network when VSDSubnet is already in use
with self.assertRaises(Exception):
self.create_Network(self.nuage_vpc_network_offering,
gateway='10.1.128.1',
vpc=vpc,
acl_list=acl_list,
externalid=subnet2.id)
# On ACS create VPCTier network when VSDSubnet does not exist
with self.assertRaises(Exception):
self.create_Network(self.nuage_vpc_network_offering,
gateway='10.1.128.1',
vpc=vpc,
acl_list=acl_list,
externalid=subnet2.id+1)
# On ACS create VPCTier network without VSDSubnet should fail
with self.assertRaises(Exception):
self.create_Network(self.nuage_vpc_network_offering,
gateway='10.1.203.1',
vpc=vpc,
acl_list=acl_list)
self.debug("Creating another VPC with Static NAT service provider "
"as VpcVirtualRouter With same CIDR")
vpc3 = self.create_Vpc(self.nuage_vpc_offering, cidr='10.1.0.0/16')
self.validate_Vpc(vpc3, state="Enabled")
acl_list3 = self.create_NetworkAclList(
name="acl", description="acl", vpc=vpc3)
self.create_NetworkAclRule(
self.test_data["ingress_rule"], acl_list=acl_list3)
self.create_NetworkAclRule(
self.test_data["icmprule"], acl_list=acl_list3)
self.debug("Creating a mngd VPC tier with Static NAT service")
vpc3_tier_unmngd = \
self.create_Network(self.nuage_vpc_network_offering,
gateway='10.1.0.1',
vpc=vpc3,
acl_list=acl_list3)
self.validate_Network(vpc3_tier_unmngd, state="Implemented")
vpc3_tier_unmngd.delete(self.api_client)
vpc3.delete(self.api_client)
self.debug("Deploying a VM in the created VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm1"
self.test_data["virtual_machine"]["name"] = "vpcvm1"
vpc_vm_1 = self.create_VM(vpc_tier, cleanup=False)
self.check_VM_state(vpc_vm_1, state="Running")
self.debug("Deploying another VM in the created VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm2"
self.test_data["virtual_machine"]["name"] = "vpcvm2"
vpc_vm_2 = self.create_VM(vpc_tier, cleanup=False)
self.check_VM_state(vpc_vm_2, state="Running")
self.debug("Deploying a VM in the 2nd VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm12"
self.test_data["virtual_machine"]["name"] = "vpcvm12"
vpc_vm_12 = self.create_VM(vpc_2ndtier, cleanup=False)
self.check_VM_state(vpc_vm_2, state="Running")
self.test_data["virtual_machine"]["displayname"] = None
self.test_data["virtual_machine"]["name"] = None
# VSD verification
self.verify_vsdmngd_vm(vpc_vm_1, subnet1)
self.verify_vsdmngd_vm(vpc_vm_2, subnet1)
self.verify_vsdmngd_vm(vpc_vm_12, subnet2)
self.debug("Creating Static NAT rule for the deployed VM "
"in the created VPC network...")
public_ip_1 = self.acquire_PublicIPAddress(vpc_tier, vpc=vpc)
self.validate_PublicIPAddress(public_ip_1, vpc_tier)
self.create_StaticNatRule_For_VM(vpc_vm_1, public_ip_1, vpc_tier)
self.validate_PublicIPAddress(
public_ip_1, vpc_tier, static_nat=True, vm=vpc_vm_1)
self.verify_ping_to_vm(vpc_vm_1, vpc_vm_2, public_ip_1)
self.verify_ping_to_vm(vpc_vm_1, vpc_vm_12, public_ip_1)
vpc_vm_1.delete(self.api_client, expunge=True)
vpc_vm_2.delete(self.api_client, expunge=True)
vpc_vm_12.delete(self.api_client, expunge=True)
vpc_tier.delete(self.api_client)
vpc_2ndtier.delete(self.api_client)
self.debug("Number of loops %s" % i)
def test_01_disable_enable_zone(self):
"""disable enable zone
1. Disable zone and verify following things:
For admin user:
1. Should be create to start/stop exsiting vms
2. Should be create to deploy new vm, snapshot,volume,
template,iso in the same zone
For Non-admin user:
1. Should be create to start/stop exsiting vms
2. Should not be create to deploy new vm, snapshot,volume,
template,iso in the same zone
2. Enable the above disabled zone and verify that:
-All users should be create to deploy new vm,
snapshot,volume,template,iso in the same zone
3. Try to delete the zone and it should fail with error message:
-"The zone is not deletable because there are
servers running in this zone"
"""
# Step 1
vm_user = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
)
vm_root = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.admin_account.name,
domainid=self.admin_account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
)
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.allocationstate = DISABLED
self.apiclient.updateZone(cmd)
zoneList = Zone.list(self.apiclient, id=self.zone.id)
self.assertEqual(zoneList[0].allocationstate, DISABLED, "Check if the zone is in disabled state")
# Both user and admin vms shoul be running
self.assertEqual(vm_user.state.lower(), "running", "Verify that the user vm is running")
self.assertEqual(vm_root.state.lower(), "running", "Verify that the admin vm is running")
vm_root.stop(self.apiclient)
vm_user.stop(self.apiclient)
root_state = self.dbclient.execute("select state from vm_instance where name='%s'" % vm_root.name)[0][0]
user_state = self.dbclient.execute("select state from vm_instance where name='%s'" % vm_user.name)[0][0]
self.assertEqual(root_state.lower(), "stopped", "verify that vm is Stopped")
self.assertEqual(user_state.lower(), "stopped", "verify that vm is stopped")
root_volume = list_volumes(self.apiclient, virtualmachineid=vm_root.id, type="ROOT", listall=True)
self.assertEqual(validateList(root_volume)[0], PASS, "list volume is empty for vmid %s" % vm_root.id)
root_vm_new = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.admin_account.name,
domainid=self.admin_account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
)
self.assertEqual(root_vm_new.state.lower(), "running", "Verify that admin should create new VM")
if self.snapshotSupported:
Snapshot.create(self.apiclient, root_volume[0].id)
snapshots = list_snapshots(self.apiclient, volumeid=root_volume[0].id, listall=True)
self.assertEqual(
validateList(snapshots)[0], PASS, "list snapshot is empty for volume id %s" % root_volume[0].id
)
Template.create_from_snapshot(self.apiclient, snapshots[0], self.testdata["privatetemplate"])
builtin_info = get_builtin_template_info(self.apiclient, self.zone.id)
self.testdata["privatetemplate"]["url"] = builtin_info[0]
self.testdata["privatetemplate"]["hypervisor"] = builtin_info[1]
self.testdata["privatetemplate"]["format"] = builtin_info[2]
"""
//commenting it for now will uncomment once expected behaviour is known
Template.register(
self.apiclient,
self.testdata["privatetemplate"],
zoneid=self.zone.id)
"""
Volume.create(
self.apiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.admin_account.name,
domainid=self.admin_account.domainid,
diskofferingid=self.disk_offering.id,
)
"""
//commenting it for now will uncomment once expected behaviour is known
Iso.create(
self.apiclient,
self.testdata["iso2"],
zoneid=self.zone.id,
account=self.admin_account.name,
domainid=self.admin_account.domainid,
)
"""
# non-admin user should fail to create vm, snap, temp etc
with self.assertRaises(Exception):
VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
)
root_volume = list_volumes(self.userapiclient, virtualmachineid=vm_user.id, type="ROOT", listall=True)
self.assertEqual(validateList(root_volume)[0], PASS, "list volume is empty for vmid id %s" % vm_user.id)
if self.snapshotSupported:
with self.assertRaises(Exception):
Snapshot.create(self.userapiclient, root_volume[0].id)
with self.assertRaises(Exception):
Template.register(self.userapiclient, self.testdata["privatetemplate"], zoneid=self.zone.id)
with self.assertRaises(Exception):
Volume.create(
self.userapiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id,
)
with self.assertRaises(Exception):
Iso.create(
self.userapiclient,
self.testdata["iso2"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
)
# Step 2
cmd.allocationstate = ENABLED
self.apiclient.updateZone(cmd)
# After enabling the zone all users should be able to add new VM,
# volume, template and iso
root_vm_new = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.admin_account.name,
domainid=self.admin_account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
)
self.assertEqual(root_vm_new.state.lower(), "running", "Verify that admin should create new VM")
if self.snapshotSupported:
Snapshot.create(self.apiclient, root_volume[0].id)
snapshots = list_snapshots(self.apiclient, volumeid=root_volume[0].id, listall=True)
self.assertEqual(
validateList(snapshots)[0], PASS, "list snapshot is empty for volume id %s" % root_volume[0].id
)
Template.create_from_snapshot(self.apiclient, snapshots[0], self.testdata["privatetemplate"])
Template.register(self.apiclient, self.testdata["privatetemplate"], zoneid=self.zone.id)
Volume.create(
self.apiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.admin_account.name,
domainid=self.admin_account.domainid,
diskofferingid=self.disk_offering.id,
)
Iso.create(
self.apiclient,
self.testdata["iso2"],
zoneid=self.zone.id,
account=self.admin_account.name,
domainid=self.admin_account.domainid,
)
# Non root user
user_vm_new = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
)
self.assertEqual(user_vm_new.state.lower(), "running", "Verify that admin should create new VM")
if self.snapshotSupported:
Snapshot.create(self.userapiclient, root_volume[0].id)
snapshots = list_snapshots(self.userapiclient, volumeid=root_volume[0].id, listall=True)
self.assertEqual(
validateList(snapshots)[0], PASS, "list snapshot is empty for volume id %s" % root_volume[0].id
)
Template.register(self.userapiclient, self.testdata["privatetemplate"], zoneid=self.zone.id)
Volume.create(
self.userapiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id,
)
Iso.create(
self.userapiclient,
self.testdata["iso2"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
)
# Step 3
# Deletion of zone should fail if vm,volume is present on the zone
with self.assertRaises(Exception):
self.zone.delete(self.apiclient)
return
def test_08_VPC_Network_Restarts_With_InternalDns(self):
""" Verify InternalDns on VPC Network with restarts and ping by
hostname
"""
# Validate the following
# 1. Create a VPC and Tier network by using DNS network offering.
# 2. Deploy vm1 in Tier network network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Deploy Vm2.
# 6. Verify end to end by pinging with hostname while restarting
# VPC and Tier without and with cleanup.
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = VPC_DOMAIN_NAME
self.apiclient.updateZone(cmd)
vpc_off = self.create_VpcOffering(self.dnsdata["vpc_offering"])
self.validate_VpcOffering(vpc_off, state="Enabled")
vpc = self.create_Vpc(vpc_off, cidr='10.1.0.0/16', cleanup=False)
self.debug("Creating Nuage Vsp VPC Network offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["vpc_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering,
gateway='10.1.1.1',
vpc=vpc)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME,
network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic,
True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
self.test_data["virtual_machine"]["displayname"] = "vm2"
self.test_data["virtual_machine"]["name"] = "vm2"
vm_2 = self.create_VM(network_1)
self.test_data["virtual_machine"]["displayname"] = "vm1"
self.test_data["virtual_machine"]["name"] = "vm1"
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic,
True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
public_ip_1 = self.acquire_PublicIPAddress(network_1, vpc)
self.create_StaticNatRule_For_VM(vm_1, public_ip_1, network_1)
# Adding Network ACL rule in the Public tier
self.debug("Adding Network ACL rule to make the created NAT rule "
"(SSH) accessible...")
public_ssh_rule = self.create_NetworkAclRule(
self.test_data["ingress_rule"], network=network_1)
# VSD verification
self.verify_vsd_firewall_rule(public_ssh_rule)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
# Restarting VPC network (cleanup = false)
self.debug("Restarting the created VPC network without cleanup...")
Network.restart(network_1, self.api_client, cleanup=False)
self.validate_Network(network_1, state="Implemented")
vr = self.get_Router(network_1)
self.check_Router_state(vr, state="Running")
self.check_VM_state(vm_1, state="Running")
self.check_VM_state(vm_2, state="Running")
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_router(vr)
self.verify_vsd_vm(vm_1)
self.verify_vsd_vm(vm_2)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
# Restarting VPC network (cleanup = true)
self.debug("Restarting the created VPC network with cleanup...")
Network.restart(network_1, self.api_client, cleanup=True)
self.validate_Network(network_1, state="Implemented")
vr = self.get_Router(network_1)
self.check_Router_state(vr, state="Running")
self.check_VM_state(vm_1, state="Running")
self.check_VM_state(vm_2, state="Running")
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_router(vr)
self.verify_vsd_vm(vm_1)
self.verify_vsd_vm(vm_2)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
# Restarting VPC (cleanup = false)
self.debug("Restarting the VPC without cleanup...")
self.restart_Vpc(vpc, cleanup=False)
self.validate_Network(network_1, state="Implemented")
vr = self.get_Router(network_1)
self.check_Router_state(vr, state="Running")
self.check_VM_state(vm_1, state="Running")
self.check_VM_state(vm_2, state="Running")
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_router(vr)
self.verify_vsd_vm(vm_1)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
# Restarting VPC (cleanup = true)
self.debug("Restarting the VPC with cleanup...")
self.restart_Vpc(vpc, cleanup=True)
self.validate_Network(network_1, state="Implemented")
vr = self.get_Router(network_1)
self.check_Router_state(vr, state="Running")
self.check_VM_state(vm_1, state="Running")
self.check_VM_state(vm_2, state="Running")
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_router(vr)
self.verify_vsd_vm(vm_1)
self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
def test_04_Update_Network_with_Domain(self):
""" Verify update NetworkDomain for InternalDns on Isolated Network
with ping VM
"""
# Validate the following
# 1. Create an Isolated network - network1 (10.1.1.1/24) by using DNS
# network offering.
# 2. Deploy vm1 in network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Update Network domain and verify it is properly updated
# update Network Domain at zone level
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "isolated.com"
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["isolated_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, "isolated.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, "isolated.com", nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
update_response = Network.update(
network_1, self.apiclient, id=network_1.id,
networkdomain="update.com", changecidr=False)
completeoutput = str(update_response).strip('[]')
self.debug("network update response is " + completeoutput)
self.assertEqual("update.com", update_response.networkdomain,
"Network Domain is not updated as expected"
)
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "update.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, "update.com", nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
# stop and start VM to get new DHCP option
try:
vm_1.stop(self.apiclient)
except Exception as e:
self.fail("Failed to stop the virtual instances, %s" % e)
self.test_data["virtual_machine"]["displayname"] = "vm2"
self.test_data["virtual_machine"]["name"] = "vm2"
vm_2 = self.create_VM(network_1)
self.test_data["virtual_machine"]["displayname"] = "vm1"
self.test_data["virtual_machine"]["name"] = "vm1"
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, "update.com", nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
try:
vm_1.start(self.apiclient)
except Exception as e:
self.fail("Failed to start the virtual instances, %s" % e)
public_ip_1 = self.acquire_PublicIPAddress(network_1)
self.create_and_verify_fw(vm_1, public_ip_1, network_1)
vm_public_ip = public_ip_1.ipaddress.ipaddress
try:
vm_1.ssh_ip = vm_public_ip
vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_1.username = self.test_data["virtual_machine"]["username"]
vm_1.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_1.ssh_ip, vm_1.password))
ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
except Exception as e:
self.fail("SSH into VM failed with exception: %s " % e)
cmd = 'ping -c 2 vm2'
self.debug("ping vm2 by hostname with command: " + cmd)
outputlist = ssh.execute(cmd)
self.debug("command is executed properly " + cmd)
completeoutput = str(outputlist).strip('[]')
self.debug("complete output is " + completeoutput)
expectedlist = ['2 received', 'vm2.update.com', vm_2.ipaddress]
for item in expectedlist:
if item in completeoutput:
self.debug("excepted value found in vm: " + item)
else:
self.fail("excepted value not found in vm: " + item)
def test_02_Isolated_Network(self):
""" Verify InternalDns on Isolated Network with ping by hostname
"""
# Validate the following
# 1. Create an Isolated network - network1 (10.1.1.1/24) by using DNS
# network offering.
# 2. Deploy vm1 in network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Deploy VM2 in network1.
# 6. Verify end to end by pinging with hostname
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "isolated.com"
self.apiclient.updateZone(cmd)
self.debug("Creating and enabling Nuage Vsp Isolated Network "
"offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["isolated_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(network_offering)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, "isolated.com", nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
self.test_data["virtual_machine"]["displayname"] = "vm2"
self.test_data["virtual_machine"]["name"] = "vm2"
vm_2 = self.create_VM(network_1)
self.test_data["virtual_machine"]["displayname"] = "vm1"
self.test_data["virtual_machine"]["name"] = "vm1"
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(
self.DOMAINNAME, "isolated.com", nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
public_ip_1 = self.acquire_PublicIPAddress(network_1)
self.create_and_verify_fw(vm_1, public_ip_1, network_1)
vm_public_ip = public_ip_1.ipaddress.ipaddress
try:
vm_1.ssh_ip = vm_public_ip
vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_1.username = self.test_data["virtual_machine"]["username"]
vm_1.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_1.ssh_ip, vm_1.password))
ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
cmd = 'ping -c 2 vm2'
self.debug("ping vm2 by hostname with command: " + cmd)
outputlist = ssh.execute(cmd)
self.debug("command is executed properly " + cmd)
completeoutput = str(outputlist).strip('[]')
self.debug("complete output is " + completeoutput)
expectedlist = ['2 received', 'vm2.isolated.com', vm_2.ipaddress]
for item in expectedlist:
if item in completeoutput:
self.debug("excepted value found in vm: " + item)
else:
self.fail("excepted value not found in vm: " + item)
def test_06_VPC_Network_With_InternalDns(self):
""" Verify InternalDns on VPC Network by ping with hostname
"""
# Validate the following
# 1. Create a VPC and Tier network by using DNS network offering.
# 2. Deploy vm1 in Tier network network1.
# 3. Verify dhcp option 06 and 0f for subnet
# 4. Verify dhcp option 06,15 and 0f for vm Interface.
# 5. Deploy Vm2.
# 6. Verify end to end by pinging with hostname
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "vpc.com"
self.apiclient.updateZone(cmd)
vpc_off = self.create_VpcOffering(self.dnsdata["vpc_offering"])
self.validate_VpcOffering(vpc_off, state="Enabled")
vpc = self.create_Vpc(vpc_off, cidr='10.1.0.0/16', cleanup=False)
self.debug("Creating Nuage Vsp VPC Network offering...")
network_offering = self.create_NetworkOffering(
self.dnsdata["vpc_network_offering"])
self.validate_NetworkOffering(network_offering, state="Enabled")
network_1 = self.create_Network(
network_offering, gateway='10.1.1.1', vpc=vpc)
vm_1 = self.create_VM(network_1)
# VSD verification
self.verify_vsd_network(self.domain.id, network_1, vpc)
self.verify_vsd_vm(vm_1)
# Internal DNS check point on VSD
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", network_1)
for nic in vm_1.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
self.test_data["virtual_machine"]["displayname"] = "vm2"
self.test_data["virtual_machine"]["name"] = "vm2"
vm_2 = self.create_VM(network_1)
self.test_data["virtual_machine"]["displayname"] = "vm1"
self.test_data["virtual_machine"]["name"] = "vm1"
self.verify_vsd_vm(vm_2)
for nic in vm_2.nic:
self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
public_ip_1 = self.acquire_PublicIPAddress(network_1, vpc)
self.create_StaticNatRule_For_VM(vm_1, public_ip_1, network_1)
# Adding Network ACL rule in the Public tier
self.debug("Adding Network ACL rule to make the created NAT rule "
"(SSH) accessible...")
public_ssh_rule = self.create_NetworkAclRule(
self.test_data["ingress_rule"], network=network_1)
# VSD verification
self.verify_vsd_firewall_rule(public_ssh_rule)
vm_public_ip = public_ip_1.ipaddress.ipaddress
try:
vm_1.ssh_ip = vm_public_ip
vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_1.username = self.test_data["virtual_machine"]["username"]
vm_1.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_1.ssh_ip, vm_1.password))
ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
cmd = 'ping -c 2 vm2'
self.debug("ping vm2 by hostname with command: " + cmd)
outputlist = ssh.execute(cmd)
self.debug("command is executed properly " + cmd)
completeoutput = str(outputlist).strip('[]')
self.debug("complete output is " + completeoutput)
expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
for item in expectedlist:
if item in completeoutput:
self.debug("excepted value found in vm: " + item)
else:
self.fail("excepted value not found in vm: " + item)
def test_02_nuage_mngd_subnets_vpc(self):
"""Test Nuage VSP Managed Subnets for vpc and tier networks
"""
# 1. Create multiple L3DomainTemplate with Zone and Subnet on VSP
# Create Ingress & Egress ACL Top & Bottom Templates
# Add ACL rules to allow intra-subnet traffic
# Instiantiate these L3Domains and store its Subnet VSD ID
# 2. Create a vpc network offering and create a VPC
# create vpc tier network offerings with and without VirtualRouter
# 3. Create vpc tier networks specifying above offerings and
# specifying the stored Subnet ID's of VSP
# 4. Verify ACL rules and connectivity via deploying VM's ,
# Enabling staticNAT, applying firewall and egress rules
# Create all items on vsd required for this test
enterprise = self.fetch_by_externalID(self._session.user.enterprises,
self.domain)
domain_template = self.create_vsd_domain_template(enterprise)
self.create_vsd_default_acls(domain_template)
domain1 = self.create_vsd_domain(domain_template, enterprise,
"L3DomainToBeConsumedByACS")
zone1 = self.create_vsd_zone(domain1, "ZoneToBeConsumedByACS")
subnet1 = self.create_vsd_subnet(zone1, "SubnetToBeConsumedByACS",
"10.1.0.1/24")
subnet2 = self.create_vsd_subnet(zone1, "2ndSubnetToBeConsumedByACS",
"10.1.128.1/24")
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "vpc.com"
self.api_client.updateZone(cmd)
self.debug("Creating a VPC with Static NAT service provider as "
"VpcVirtualRouter")
vpc = self.create_Vpc(self.nuage_vpc_offering, cidr='10.1.0.0/16')
self.validate_Vpc(vpc, state="Enabled")
acl_list = self.create_NetworkAclList(name="acl",
description="acl",
vpc=vpc)
self.create_NetworkAclRule(self.test_data["ingress_rule"],
acl_list=acl_list)
self.create_NetworkAclRule(self.test_data["icmprule"],
acl_list=acl_list)
self.debug("Creating a VPC tier network with Static NAT service")
vpc_tier = self.create_Network(self.nuage_vpc_network_offering,
gateway='10.1.0.1',
vpc=vpc,
acl_list=acl_list,
externalid=subnet1.id)
self.validate_Network(vpc_tier, state="Implemented")
self.debug("Creating 2nd VPC tier network with Static NAT service")
vpc_2ndtier = self.create_Network(self.nuage_vpc_network_offering,
gateway='10.1.128.1',
vpc=vpc,
acl_list=acl_list,
externalid=subnet2.id)
self.validate_Network(vpc_2ndtier, state="Implemented")
vpc_vr = self.get_Router(vpc_tier)
self.check_Router_state(vpc_vr, state="Running")
self.debug("Deploying a VM in the created VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm1"
self.test_data["virtual_machine"]["name"] = "vpcvm1"
vpc_vm_1 = self.create_VM(vpc_tier)
self.check_VM_state(vpc_vm_1, state="Running")
self.debug("Deploying another VM in the created VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm2"
self.test_data["virtual_machine"]["name"] = "vpcvm2"
vpc_vm_2 = self.create_VM(vpc_tier)
self.check_VM_state(vpc_vm_2, state="Running")
self.debug("Deploying a VM in the 2nd VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm12"
self.test_data["virtual_machine"]["name"] = "vpcvm12"
vpc_vm_12 = self.create_VM(vpc_2ndtier)
self.check_VM_state(vpc_vm_2, state="Running")
self.test_data["virtual_machine"]["displayname"] = None
self.test_data["virtual_machine"]["name"] = None
self.debug("Creating Static NAT rule for the deployed VM "
"in the created VPC network...")
public_ip_1 = self.acquire_PublicIPAddress(vpc_tier, vpc=vpc)
self.validate_PublicIPAddress(public_ip_1, vpc_tier)
self.create_StaticNatRule_For_VM(vpc_vm_1, public_ip_1, vpc_tier)
self.validate_PublicIPAddress(public_ip_1,
vpc_tier,
static_nat=True,
vm=vpc_vm_1)
if not self.isSimulator:
vm_public_ip_1 = public_ip_1.ipaddress.ipaddress
try:
vpc_vm_1.ssh_ip = vm_public_ip_1
vpc_vm_1.ssh_port = \
self.test_data["virtual_machine"]["ssh_port"]
vpc_vm_1.username = \
self.test_data["virtual_machine"]["username"]
vpc_vm_1.password = \
self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vpc_vm_1.ssh_ip, vpc_vm_1.password))
ssh = vpc_vm_1.get_ssh_client(ipaddress=vm_public_ip_1)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
self.verify_pingtovmipaddress(ssh, vpc_vm_2.ipaddress)
self.verify_pingtovmipaddress(ssh, vpc_vm_12.ipaddress)
