mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
4c91c9c519
BUG-ID: CLOUDSTACK-9403 Co-Authored-By: Prashanth Manthena <prashanth.manthena@nuagenetworks.net> Co-Authored-By: Rahul Singal <rahul.singal@nuagenetworks.net> Co-Authored-By: Sigert Goeminne <sigert.goeminne@nuagenetworks.net> Co-Authored-By: Nick Livens <nick.livens@nuagenetworks.net>
1459 lines
70 KiB
Python
1459 lines
70 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.
|
|
|
|
""" Component tests for Source NAT functionality with Nuage VSP SDN plugin
|
|
"""
|
|
# Import Local Modules
|
|
from nuageTestCase import nuageTestCase
|
|
from marvin.lib.base import (Account,
|
|
Network,
|
|
VirtualMachine)
|
|
# Import System Modules
|
|
from nose.plugins.attrib import attr
|
|
import copy
|
|
import time
|
|
|
|
|
|
class TestNuageSourceNat(nuageTestCase):
|
|
"""Test Source NAT functionality with Nuage VSP SDN plugin
|
|
"""
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super(TestNuageSourceNat, cls).setUpClass()
|
|
return
|
|
|
|
def setUp(self):
|
|
# Create an account
|
|
self.account = Account.create(self.api_client,
|
|
self.test_data["account"],
|
|
admin=True,
|
|
domainid=self.domain.id
|
|
)
|
|
self.cleanup = [self.account]
|
|
return
|
|
|
|
# verify_vsd_SourceNAT_network - Verifies if Source NAT functionality of
|
|
# the given network is enabled in VSD
|
|
def verify_vsd_SourceNAT_network(self, network, vpc=None):
|
|
self.debug("Verifying if Source NAT functionality of Network - %s is "
|
|
"enabled in VSD" % network.name)
|
|
ext_network_id_filter = self.get_externalID_filter(vpc.id) if vpc \
|
|
else self.get_externalID_filter(network.id)
|
|
vsd_domain = self.vsd.get_domain(filter=ext_network_id_filter)
|
|
self.assertEqual(vsd_domain.pat_enabled, "ENABLED",
|
|
"VSD domain address translation support "
|
|
"(pat_enabled flag) should be enabled for Source NAT "
|
|
"service enabled network in CloudStack"
|
|
)
|
|
self.assertEqual(vsd_domain.underlay_enabled, "ENABLED",
|
|
"VSD domain underlay support (underlay_enabled flag) "
|
|
"should be enabled for Source NAT service enabled "
|
|
"network in CloudStack"
|
|
)
|
|
self.debug("Successfully verified that Source NAT functionality of "
|
|
"Network - %s is enabled in VSD" % network.name)
|
|
|
|
# verify_SourceNAT_VM_traffic - Verifies Source NAT traffic
|
|
# (wget www.google.com) to the Internet from the given VM. This Source NAT
|
|
# traffic test is done through a custom init script in the guest VM
|
|
# template upon the VM boot up.
|
|
def verify_SourceNAT_VM_traffic(self, vm, network, vpc=None,
|
|
negative_test=False):
|
|
self.debug("Verifying Source NAT traffic (wget www.google.com) to the "
|
|
"Internet from VM - %s" % vm.name)
|
|
if self.isInternetConnectivityAvailable:
|
|
# Adding Egress Network ACL rule
|
|
if vpc and self.http_proxy and not negative_test:
|
|
self.debug("Adding Egress Network ACL rule in the created VPC "
|
|
"network to allow access to the configured "
|
|
"Internet proxy servers...")
|
|
proxy_rule = copy.deepcopy(self.test_data["http_rule"])
|
|
proxy_rule["privateport"] = 1080
|
|
proxy_rule["publicport"] = 1080
|
|
proxy_rule["startport"] = 1080
|
|
proxy_rule["endport"] = 1080
|
|
internet_proxy_server_rule = self.create_NetworkAclRule(
|
|
proxy_rule, traffic_type="Egress", network=network)
|
|
|
|
# VSD verification
|
|
self.verify_vsd_firewall_rule(
|
|
internet_proxy_server_rule, traffic_type="Egress")
|
|
|
|
# Triggering Source NAT traffic test
|
|
# Rebooting (stop - start) VM
|
|
self.debug("Triggering the Source NAT traffic test by rebooting "
|
|
"the given VM...")
|
|
vm.stop(self.api_client)
|
|
vm.start(self.api_client)
|
|
self.check_VM_state(vm, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_vm(vm)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network, vpc)
|
|
|
|
self.debug("Waiting for the VM to perform the Source NAT traffic "
|
|
"test (wget www.google.com) to the Internet...")
|
|
time.sleep(180) if negative_test else time.sleep(300)
|
|
|
|
# Creating Static NAT rule
|
|
self.debug("Creating Static NAT rule to SSH into the VM for "
|
|
"verifying its Source NAT traffic test...")
|
|
public_ip = self.acquire_PublicIPAddress(network, vpc=vpc)
|
|
self.validate_PublicIPAddress(public_ip, network)
|
|
self.create_StaticNatRule_For_VM(vm, public_ip, network)
|
|
self.validate_PublicIPAddress(
|
|
public_ip, network, static_nat=True, vm=vm)
|
|
|
|
# VSD verification
|
|
updated_vm_info = VirtualMachine.list(self.api_client, id=vm.id)[0]
|
|
self.verify_vsd_floating_ip(
|
|
network, updated_vm_info, public_ip.ipaddress, vpc=vpc)
|
|
|
|
# Adding Ingress Firewall/Network ACL rule
|
|
self.debug("Adding Ingress Firewall/Network ACL rule to make the "
|
|
"created Static NAT rule (SSH) accessible...")
|
|
if vpc:
|
|
public_ssh_rule = self.create_NetworkAclRule(
|
|
self.test_data["ingress_rule"], network=network)
|
|
else:
|
|
public_ssh_rule = self.create_FirewallRule(
|
|
public_ip, self.test_data["ingress_rule"])
|
|
|
|
# VSD verification
|
|
self.verify_vsd_firewall_rule(public_ssh_rule)
|
|
|
|
# Checking for wget file
|
|
ssh_client = self.ssh_into_VM(vm, public_ip)
|
|
cmd = "ls /"
|
|
file_list = self.execute_cmd(ssh_client, cmd)
|
|
if "index.html" in str(file_list):
|
|
cmd = "rm -rf /index.html*"
|
|
self.execute_cmd(ssh_client, cmd)
|
|
|
|
# Removing Ingress Firewall/Network ACL rule
|
|
self.debug("Removing the created Ingress Firewall/Network ACL "
|
|
"rule in the network...")
|
|
public_ssh_rule.delete(self.api_client)
|
|
|
|
# VSD verification
|
|
with self.assertRaises(Exception):
|
|
self.verify_vsd_firewall_rule(public_ssh_rule)
|
|
self.debug("Ingress Firewall/Network ACL rule successfully "
|
|
"deleted in VSD")
|
|
|
|
# Deleting Static NAT Rule
|
|
self.debug("Deleting Static NAT Rule for the VM...")
|
|
self.delete_StaticNatRule_For_VM(public_ip)
|
|
with self.assertRaises(Exception):
|
|
self.validate_PublicIPAddress(
|
|
public_ip, network, static_nat=True, vm=vm)
|
|
self.debug("Static NAT Rule for the VM successfully deleted in "
|
|
"CloudStack")
|
|
|
|
# VSD verification
|
|
with self.assertRaises(Exception):
|
|
self.verify_vsd_floating_ip(
|
|
network, updated_vm_info, public_ip.ipaddress, vpc=vpc)
|
|
self.debug("Floating IP for the VM successfully deleted in VSD")
|
|
|
|
# Releasing acquired public IP
|
|
self.debug("Releasing the acquired public IP in the network...")
|
|
public_ip.delete(self.api_client)
|
|
with self.assertRaises(Exception):
|
|
self.validate_PublicIPAddress(public_ip, network)
|
|
self.debug("Acquired public IP in the network successfully "
|
|
"released in CloudStack")
|
|
|
|
# Removing Egress Network ACL rule
|
|
if vpc and self.http_proxy:
|
|
self.debug("Removing the created Egress Network ACL rule in "
|
|
"the VPC network...")
|
|
internet_proxy_server_rule.delete(self.api_client)
|
|
|
|
# VSD verification
|
|
with self.assertRaises(Exception):
|
|
self.verify_vsd_firewall_rule(internet_proxy_server_rule)
|
|
self.debug("Egress Network ACL rule successfully deleted in "
|
|
"VSD")
|
|
|
|
# Final test result
|
|
if "index.html" in str(file_list):
|
|
self.debug("Successfully verified Source NAT traffic "
|
|
"(wget www.google.com) to the Internet from VM - %s"
|
|
% vm.name)
|
|
else:
|
|
self.fail("Failed to verify Source NAT traffic "
|
|
"(wget www.google.com) to the Internet from VM - %s"
|
|
% vm.name)
|
|
else:
|
|
if negative_test:
|
|
self.fail("Skipping Source NAT traffic (wget www.google.com) "
|
|
"verification to the Internet from VM as there is "
|
|
"no Internet connectivity in the data center")
|
|
else:
|
|
self.debug("Skipping Source NAT traffic (wget www.google.com) "
|
|
"verification to the Internet from VM as there is "
|
|
"no Internet connectivity in the data center")
|
|
|
|
@attr(tags=["advanced", "nuagevsp"], required_hardware="false")
|
|
def test_01_nuage_SourceNAT_isolated_networks(self):
|
|
"""Test Nuage VSP Isolated networks with different combinations of
|
|
Source NAT service providers
|
|
"""
|
|
|
|
# 1. Create Nuage VSP Isolated Network offerings and corresponding
|
|
# Isolated networks with different combinations of Source NAT
|
|
# service providers (NuageVsp, VirtualRouter, no SourceNat service),
|
|
# check if only the Isolated networks with Source NAT service
|
|
# provider as NuageVsp are successfully created.
|
|
# 2. Recreate the above created Network offering with ispersistent flag
|
|
# set to True, check if the network offering is successfully created
|
|
# and enabled.
|
|
# 3. Recreate the above created Network offering with conserve mode On
|
|
# (conserve_mode flag set to True), check if the network offering is
|
|
# successfully created and enabled.
|
|
# 4. Recreate the above created Network offering with Source NAT
|
|
# Service Capability SupportedSourceNatTypes as per account, check
|
|
# if the network offering creation failed as Nuage VSP supports only
|
|
# SupportedSourceNatTypes as per zone.
|
|
# 5. Create an Isolated network with Source NAT service provider as
|
|
# NuageVsp and spawn a VM, check if the network is successfully
|
|
# created, and the VM along with the VR is deployed successfully in
|
|
# the network. Verify if the Source NAT functionality for this
|
|
# network is successfully enabled in VSD.
|
|
# 6. Create a persistent Isolated network with Source NAT service
|
|
# provider as NuageVsp and spawn a VM, check if the network is
|
|
# successfully created, and the VM along with the VR is deployed
|
|
# successfully in the network. Verify if the Source NAT
|
|
# functionality for this network is successfully enabled in VSD.
|
|
# 7. Create a conserved Isolated network (conserve mode On) with Source
|
|
# NAT service provider as NuageVsp and spawn a VM, check if the
|
|
# network is successfully created, and the VM along with the VR is
|
|
# deployed successfully in the network. Verify if the Source NAT
|
|
# functionality for this network is successfully enabled in VSD.
|
|
# 8. Delete all the created objects (cleanup).
|
|
|
|
# Creating network offerings
|
|
self.debug("Creating Nuage VSP Isolated Network offering with Source "
|
|
"NAT service provider as NuageVsp...")
|
|
net_off_1 = self.create_NetworkOffering(
|
|
self.test_data["nuagevsp"]["isolated_network_offering"])
|
|
self.validate_NetworkOffering(net_off_1, state="Enabled")
|
|
|
|
self.debug("Recreating above Network offering with ispersistent "
|
|
"True...")
|
|
network_offering = copy.deepcopy(
|
|
self.test_data["nuagevsp"]["isolated_network_offering"])
|
|
network_offering["ispersistent"] = "True"
|
|
net_off_2 = self.create_NetworkOffering(network_offering)
|
|
self.validate_NetworkOffering(net_off_2, state="Enabled")
|
|
|
|
self.debug("Recreating above Network offering with conserve mode "
|
|
"On...")
|
|
net_off_3 = self.create_NetworkOffering(
|
|
self.test_data["nuagevsp"]["isolated_network_offering"],
|
|
conserve_mode=True)
|
|
self.validate_NetworkOffering(net_off_3, state="Enabled")
|
|
|
|
self.debug("Recreating above Network offering with Source NAT Service "
|
|
"Capability SupportedSourceNatTypes as per account...")
|
|
network_offering = copy.deepcopy(
|
|
self.test_data["nuagevsp"]["isolated_network_offering"])
|
|
service_list = network_offering["serviceCapabilityList"]
|
|
service_list["SourceNat"]["SupportedSourceNatTypes"] = "peraccount"
|
|
network_offering["serviceCapabilityList"] = service_list
|
|
with self.assertRaises(Exception):
|
|
self.create_NetworkOffering(network_offering)
|
|
self.debug("Nuage VSP does not support Network offerings with Source "
|
|
"NAT Service Capability "
|
|
"SupportedSourceNatTypes as per account")
|
|
|
|
self.debug("Creating Nuage VSP Isolated Network offering with Source "
|
|
"NAT service provider as VirtualRouter...")
|
|
network_offering = copy.deepcopy(
|
|
self.test_data["nuagevsp"]["isolated_network_offering"])
|
|
network_offering["serviceProviderList"]["SourceNat"] = "VirtualRouter"
|
|
with self.assertRaises(Exception):
|
|
self.create_NetworkOffering(network_offering)
|
|
self.debug("Nuage VSP does not support Network offerings with Source "
|
|
"NAT service provider as VirtualRouter")
|
|
|
|
self.debug("Creating Nuage VSP Isolated Network offering without "
|
|
"Source NAT service...")
|
|
network_offering = copy.deepcopy(
|
|
self.test_data["nuagevsp"]["isolated_network_offering"])
|
|
network_offering["supportedservices"] = \
|
|
'Dhcp,Connectivity,StaticNat,UserData,Firewall,Dns'
|
|
del network_offering["serviceProviderList"]["SourceNat"]
|
|
del network_offering["serviceCapabilityList"]
|
|
net_off_4 = self.create_NetworkOffering(network_offering)
|
|
|
|
# Creating Isolated networks, and deploying VMs
|
|
self.debug("Creating an Isolated network with Source NAT service "
|
|
"provider as NuageVsp...")
|
|
network_1 = self.create_Network(net_off_1, gateway='10.1.1.1')
|
|
self.validate_Network(network_1, state="Allocated")
|
|
|
|
self.debug("Deploying a VM in the created Isolated network...")
|
|
vm_1 = self.create_VM(network_1)
|
|
self.validate_Network(network_1, state="Implemented")
|
|
vr_1 = self.get_Router(network_1)
|
|
self.check_Router_state(vr_1, state="Running")
|
|
self.check_VM_state(vm_1, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, network_1)
|
|
self.verify_vsd_router(vr_1)
|
|
self.verify_vsd_vm(vm_1)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network_1)
|
|
|
|
# Bug CLOUDSTACK-9398
|
|
"""
|
|
self.debug("Creating a persistent Isolated network with Source NAT "
|
|
"service...")
|
|
network_2 = self.create_Network(net_off_2, gateway='10.1.2.1')
|
|
self.validate_Network(network_2, state="Implemented")
|
|
vr_2 = self.get_Router(network_2)
|
|
self.check_Router_state(vr_2, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, network_2)
|
|
self.verify_vsd_router(vr_2)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network_2)
|
|
|
|
self.debug("Deploying a VM in the created Isolated network...")
|
|
vm_2 = self.create_VM(network_2)
|
|
self.check_VM_state(vm_2, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_vm(vm_2)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network_2)
|
|
"""
|
|
|
|
self.debug("Creating an Isolated network with Source NAT service and "
|
|
"conserve mode On...")
|
|
network_3 = self.create_Network(net_off_3, gateway='10.1.3.1')
|
|
self.validate_Network(network_3, state="Allocated")
|
|
|
|
self.debug("Deploying a VM in the created Isolated network...")
|
|
vm_3 = self.create_VM(network_3)
|
|
self.validate_Network(network_3, state="Implemented")
|
|
vr_3 = self.get_Router(network_3)
|
|
self.check_Router_state(vr_3, state="Running")
|
|
self.check_VM_state(vm_3, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, network_3)
|
|
self.verify_vsd_router(vr_3)
|
|
self.verify_vsd_vm(vm_3)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network_3)
|
|
|
|
self.debug("Creating an Isolated network without Source NAT "
|
|
"service...")
|
|
with self.assertRaises(Exception):
|
|
self.create_Network(net_off_4, gateway='10.1.4.1')
|
|
self.debug("Nuage VSP does not support creation of Isolated networks "
|
|
"without Source NAT service")
|
|
|
|
@attr(tags=["advanced", "nuagevsp"], required_hardware="false")
|
|
def test_02_nuage_SourceNAT_vpc_networks(self):
|
|
"""Test Nuage VSP VPC networks with different combinations of Source
|
|
NAT service providers
|
|
"""
|
|
|
|
# 1. Create Nuage VSP VPC offering with different combinations of
|
|
# Source NAT service providers
|
|
# (NuageVsp, VirtualRouter, no SourceNat service), check if all the
|
|
# VPC offerings are successfully created and enabled.
|
|
# 2. Create VPCs with different combinations of Source NAT service
|
|
# providers (NuageVsp, VirtualRouter, no SourceNat service), check
|
|
# if only the VPCs with Source NAT service provider as NuageVsp and
|
|
# no SourceNat service are successfully created and enabled.
|
|
# 3. Create Nuage VSP VPC Network offering with different combinations
|
|
# of Source NAT service providers
|
|
# (NuageVsp, VirtualRouter, no SourceNat service), check if only the
|
|
# network offering with Source NAT service provider as NuageVsp is
|
|
# successfully created and enabled.
|
|
# 4. Recreate the above created Network offering with ispersistent flag
|
|
# set to False, check if the network offering is successfully
|
|
# created and enabled.
|
|
# 5. Recreate the above created Network offering with conserve mode On
|
|
# (conserve_mode flag set to True), check if the network offering
|
|
# creation failed as only networks with conserve mode Off can belong
|
|
# to VPC.
|
|
# 6. Recreate the above created Network offering with with Source NAT
|
|
# Service Capability SupportedSourceNatTypes as per account, check
|
|
# if the network offering creation failed as Nuage VSP supports only
|
|
# SupportedSourceNatTypes as per zone.
|
|
# 7. Create a VPC network with Source NAT service provider as NuageVsp
|
|
# in the VPC with SourceNat service and spawn a VM, check if the
|
|
# tier is added to the VPC VR, and the VM is deployed successfully
|
|
# in the tier. Verify if the Source NAT functionality for this
|
|
# network is successfully enabled in VSD.
|
|
# 8. Create a non persistent VPC network with Source NAT service
|
|
# provider as NuageVsp in the VPC with SourceNat service and spawn a
|
|
# VM, check if the tier creation failed as Nuage VSP does not
|
|
# support non persistent VPC networks.
|
|
# 9. Create another VPC network with Source NAT service provider as
|
|
# NuageVsp in the VPC with SourceNat service and spawn a VM, check
|
|
# if the tier is added to the VPC VR, and the VM is deployed
|
|
# successfully in the tier. Verify if the Source NAT functionality
|
|
# for this network is successfully enabled in VSD.
|
|
# 10. Create a VPC network with Source NAT service provider as NuageVsp
|
|
# in the VPC without SourceNat service, check if the tier creation
|
|
# failed as the VPC does not support Source NAT service.
|
|
# 11. Delete all the created objects (cleanup).
|
|
|
|
# Creating VPC offerings
|
|
self.debug("Creating Nuage VSP VPC offering with Source NAT service "
|
|
"provider as NuageVsp...")
|
|
vpc_off_1 = self.create_VpcOffering(
|
|
self.test_data["nuagevsp"]["vpc_offering"])
|
|
self.validate_VpcOffering(vpc_off_1, state="Enabled")
|
|
|
|
self.debug("Creating Nuage VSP VPC offering with Source NAT service "
|
|
"provider as VpcVirtualRouter...")
|
|
vpc_offering = copy.deepcopy(
|
|
self.test_data["nuagevsp"]["vpc_offering"])
|
|
vpc_offering["serviceProviderList"]["SourceNat"] = "VpcVirtualRouter"
|
|
vpc_off_2 = self.create_VpcOffering(vpc_offering)
|
|
self.validate_VpcOffering(vpc_off_2, state="Enabled")
|
|
|
|
self.debug("Creating Nuage VSP VPC offering without Source NAT "
|
|
"service...")
|
|
vpc_offering = copy.deepcopy(
|
|
self.test_data["nuagevsp"]["vpc_offering"])
|
|
vpc_offering["supportedservices"] = \
|
|
'Dhcp,StaticNat,NetworkACL,Connectivity,UserData,Dns'
|
|
del vpc_offering["serviceProviderList"]["SourceNat"]
|
|
vpc_off_3 = self.create_VpcOffering(vpc_offering)
|
|
self.validate_VpcOffering(vpc_off_3, state="Enabled")
|
|
|
|
# Creating VPCs
|
|
self.debug("Creating a VPC with Source NAT service provider as "
|
|
"NuageVsp...")
|
|
vpc_1 = self.create_Vpc(vpc_off_1, cidr='10.1.0.0/16')
|
|
self.validate_Vpc(vpc_1, state="Enabled")
|
|
|
|
self.debug("Creating a VPC with Source NAT service provider as "
|
|
"VpcVirtualRouter...")
|
|
with self.assertRaises(Exception):
|
|
self.create_Vpc(vpc_off_2, cidr='10.1.0.0/16')
|
|
self.debug("Nuage VSP does not support provider VpcVirtualRouter for "
|
|
"service Source NAT for VPCs")
|
|
|
|
self.debug("Creating a VPC without Source NAT service...")
|
|
with self.assertRaises(Exception):
|
|
self.create_Vpc(vpc_off_3, cidr='10.1.0.0/16')
|
|
self.debug("Nuage VSP does not support VPCs without Source NAT "
|
|
"service")
|
|
|
|
# Creating network offerings
|
|
self.debug("Creating Nuage VSP VPC Network offering with Source NAT "
|
|
"service provider as NuageVsp...")
|
|
net_off_1 = self.create_NetworkOffering(
|
|
self.test_data["nuagevsp"]["vpc_network_offering"])
|
|
self.validate_NetworkOffering(net_off_1, state="Enabled")
|
|
|
|
self.debug("Recreating above Network offering with ispersistent "
|
|
"False...")
|
|
network_offering = copy.deepcopy(
|
|
self.test_data["nuagevsp"]["vpc_network_offering"])
|
|
network_offering["ispersistent"] = "False"
|
|
net_off_2 = self.create_NetworkOffering(network_offering)
|
|
self.validate_NetworkOffering(net_off_2, state="Enabled")
|
|
|
|
self.debug("Recreating above Network offering with conserve mode "
|
|
"On...")
|
|
with self.assertRaises(Exception):
|
|
self.create_NetworkOffering(
|
|
self.test_data["nuagevsp"]["vpc_network_offering"],
|
|
conserve_mode=True)
|
|
self.debug("Network offering creation failed as only networks with "
|
|
"conserve mode Off can belong to VPC")
|
|
|
|
self.debug("Recreating above Network offering with Source NAT Service "
|
|
"Capability SupportedSourceNatTypes as per account...")
|
|
network_offering = copy.deepcopy(
|
|
self.test_data["nuagevsp"]["vpc_network_offering"])
|
|
service_list = network_offering["serviceCapabilityList"]
|
|
service_list["SourceNat"]["SupportedSourceNatTypes"] = "peraccount"
|
|
network_offering["serviceCapabilityList"] = service_list
|
|
with self.assertRaises(Exception):
|
|
self.create_NetworkOffering(network_offering)
|
|
self.debug("Nuage VSP does not support Network offerings with Source "
|
|
"NAT Service Capability SupportedSourceNatTypes as per "
|
|
"account")
|
|
|
|
self.debug("Creating Nuage VSP VPC Network offering with Source NAT "
|
|
"service provider as VpcVirtualRouter...")
|
|
network_offering = copy.deepcopy(
|
|
self.test_data["nuagevsp"]["vpc_network_offering"])
|
|
network_offering["serviceProviderList"]["SourceNat"] = \
|
|
"VpcVirtualRouter"
|
|
with self.assertRaises(Exception):
|
|
self.create_NetworkOffering(network_offering)
|
|
self.debug("Nuage VSP does not support Network offerings with Source "
|
|
"NAT service provider as VpcVirtualRouter")
|
|
|
|
self.debug("Creating Nuage VSP VPC Network offering without Source "
|
|
"NAT service...")
|
|
network_offering = copy.deepcopy(
|
|
self.test_data["nuagevsp"]["vpc_network_offering"])
|
|
network_offering["supportedservices"] = \
|
|
'Dhcp,StaticNat,NetworkACL,Connectivity,UserData,Dns'
|
|
del network_offering["serviceProviderList"]["SourceNat"]
|
|
del network_offering["serviceCapabilityList"]
|
|
with self.assertRaises(Exception):
|
|
self.create_NetworkOffering(network_offering)
|
|
self.debug("Nuage VSP does not support Network offerings without "
|
|
"Source NAT service")
|
|
|
|
# Creating VPC networks in the VPCs, and deploying VMs
|
|
self.debug("Creating a VPC network with Source NAT service provider "
|
|
"as NuageVsp in vpc_1...")
|
|
vpc_tier_1 = self.create_Network(
|
|
net_off_1, gateway='10.1.1.1', vpc=vpc_1)
|
|
self.validate_Network(vpc_tier_1, state="Implemented")
|
|
vpc_vr = self.get_Router(vpc_tier_1)
|
|
self.check_Router_state(vpc_vr, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, vpc_tier_1, vpc_1)
|
|
self.verify_vsd_router(vpc_vr)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(vpc_tier_1, vpc=vpc_1)
|
|
|
|
self.debug("Deploying a VM in the created VPC network...")
|
|
vpc_vm_1 = self.create_VM(vpc_tier_1)
|
|
self.check_VM_state(vpc_vm_1, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_vm(vpc_vm_1)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(vpc_tier_1, vpc=vpc_1)
|
|
|
|
self.debug("Creating a non persistent VPC network with Source NAT "
|
|
"service in vpc_1...")
|
|
with self.assertRaises(Exception):
|
|
self.create_Network(net_off_2, gateway='10.1.2.1', vpc=vpc_1)
|
|
self.debug("Nuage VSP does not support non persistent VPC networks")
|
|
|
|
self.debug("Creating another VPC network with Source NAT service in "
|
|
"vpc_1...")
|
|
vpc_tier_2 = self.create_Network(
|
|
net_off_1, gateway='10.1.2.1', vpc=vpc_1)
|
|
self.validate_Network(vpc_tier_2, state="Implemented")
|
|
vpc_vr = self.get_Router(vpc_tier_2)
|
|
self.check_Router_state(vpc_vr, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, vpc_tier_2, vpc_1)
|
|
self.verify_vsd_router(vpc_vr)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(vpc_tier_2, vpc=vpc_1)
|
|
|
|
self.debug("Deploying a VM in the created VPC network...")
|
|
vpc_vm_2 = self.create_VM(vpc_tier_2)
|
|
self.check_VM_state(vpc_vm_2, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_vm(vpc_vm_2)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(vpc_tier_2, vpc=vpc_1)
|
|
|
|
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
|
|
def test_03_nuage_SourceNAT_isolated_network_traffic(self):
|
|
"""Test Nuage VSP Source NAT functionality for Isolated network by
|
|
performing (wget) traffic tests to the Internet
|
|
"""
|
|
|
|
# 1. Check if the configured Nuage VSP SDN platform infrastructure
|
|
# supports underlay networking, if not, skip this test.
|
|
# 2. Create an Isolated network with Source NAT service provider as
|
|
# NuageVsp and spawn a VM, check if the network is successfully
|
|
# created, and the VM along with the VR is deployed successfully in
|
|
# the network. Verify if the Source NAT functionality for this
|
|
# network is successfully enabled in VSD.
|
|
# 3. Verify Source NAT traffic test (wget www.google.com) to the
|
|
# Internet from the deployed VM.
|
|
# 4. Deploy another VM in the created Isolated network, check if the VM
|
|
# is deployed successfully in the network. Verify if the Source NAT
|
|
# functionality for this network is successfully enabled in VSD.
|
|
# 5. Verify Source NAT traffic test (wget www.google.com) to the
|
|
# Internet from the deployed VM.
|
|
# 6. Delete all the created objects (cleanup).
|
|
# Note: Above mentioned Source NAT traffic tests are done through a
|
|
# custom init script in the guest VM template upon the VM boot
|
|
# up. This traffic tests are verified by SSHing into the VM
|
|
# using a Static NAT rule.
|
|
|
|
if not self.isNuageInfraUnderlay:
|
|
self.skipTest("Configured Nuage VSP SDN platform infrastructure "
|
|
"does not support underlay networking: "
|
|
"skipping test")
|
|
|
|
# Creating network offering
|
|
self.debug("Creating Nuage VSP Isolated Network offering with Source "
|
|
"NAT service provider as NuageVsp...")
|
|
net_off = self.create_NetworkOffering(
|
|
self.test_data["nuagevsp"]["isolated_network_offering"])
|
|
self.validate_NetworkOffering(net_off, state="Enabled")
|
|
|
|
# Creating Isolated networks, deploying VMs, and verifying Source NAT
|
|
# traffic
|
|
self.debug("Creating an Isolated network with Source NAT service...")
|
|
network = self.create_Network(net_off, gateway='10.1.1.1')
|
|
self.validate_Network(network, state="Allocated")
|
|
|
|
self.debug("Deploying a VM in the created Isolated network...")
|
|
vm_1 = self.create_VM(network)
|
|
self.validate_Network(network, state="Implemented")
|
|
vr = self.get_Router(network)
|
|
self.check_Router_state(vr, state="Running")
|
|
self.check_VM_state(vm_1, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, network)
|
|
self.verify_vsd_router(vr)
|
|
self.verify_vsd_vm(vm_1)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm_1, network)
|
|
|
|
self.debug("Deploying another VM in the created Isolated network...")
|
|
vm_2 = self.create_VM(network)
|
|
self.check_VM_state(vm_2, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_vm(vm_2)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm_2, network)
|
|
|
|
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
|
|
def test_04_nuage_SourceNAT_vpc_network_traffic(self):
|
|
"""Test Nuage VSP Source NAT functionality for VPC network by
|
|
performing (wget) traffic tests to the Internet
|
|
"""
|
|
|
|
# 1. Check if the configured Nuage VSP SDN platform infrastructure
|
|
# supports underlay networking, if not, skip this test.
|
|
# 2. Create a VPC network with Source NAT service provider as NuageVsp
|
|
# in the VPC with SourceNat service and spawn a VM, check if the
|
|
# tier is added to the VPC VR, and the VM is deployed successfully
|
|
# in the tier. Verify if the Source NAT functionality for this
|
|
# network is successfully enabled in VSD.
|
|
# 3. Verify Source NAT traffic test (wget www.google.com) to the
|
|
# Internet from the deployed VM.
|
|
# 4. Deploy another VM in the created VPC network, check if the VM is
|
|
# deployed successfully in the network. Verify if the Source NAT
|
|
# functionality for this network is successfully enabled in VSD.
|
|
# 5. Verify Source NAT traffic test (wget www.google.com) to the
|
|
# Internet from the deployed VM.
|
|
# 6. Delete all the created objects (cleanup).
|
|
# Note: Above mentioned Source NAT traffic tests are done through a
|
|
# custom init script in the guest VM template upon the VM boot
|
|
# up. This traffic tests are verified by SSHing into the VM using
|
|
# a Static NAT rule.
|
|
|
|
if not self.isNuageInfraUnderlay:
|
|
self.skipTest("Configured Nuage VSP SDN platform infrastructure "
|
|
"does not support underlay networking: "
|
|
"skipping test")
|
|
|
|
# Creating VPC offering
|
|
self.debug("Creating Nuage VSP VPC offering with Source NAT service "
|
|
"provider as NuageVsp...")
|
|
vpc_off = self.create_VpcOffering(
|
|
self.test_data["nuagevsp"]["vpc_offering"])
|
|
self.validate_VpcOffering(vpc_off, state="Enabled")
|
|
|
|
# Creating VPC
|
|
self.debug("Creating a VPC with Source NAT service provider as "
|
|
"NuageVsp...")
|
|
vpc = self.create_Vpc(vpc_off, cidr='10.1.0.0/16')
|
|
self.validate_Vpc(vpc, state="Enabled")
|
|
|
|
# Creating network offering
|
|
self.debug("Creating Nuage VSP VPC Network offering with Source NAT "
|
|
"service provider as NuageVsp...")
|
|
net_off = self.create_NetworkOffering(
|
|
self.test_data["nuagevsp"]["vpc_network_offering"])
|
|
self.validate_NetworkOffering(net_off, state="Enabled")
|
|
|
|
# Creating VPC networks in the VPC, deploying VMs, and verifying
|
|
# Source NAT traffic
|
|
self.debug("Creating a VPC network with Source NAT service...")
|
|
vpc_tier = self.create_Network(net_off, gateway='10.1.1.1', vpc=vpc)
|
|
self.validate_Network(vpc_tier, state="Implemented")
|
|
vpc_vr = self.get_Router(vpc_tier)
|
|
self.check_Router_state(vpc_vr, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, vpc_tier, vpc)
|
|
self.verify_vsd_router(vpc_vr)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(vpc_tier, vpc=vpc)
|
|
|
|
# Adding Egress Network ACL rules
|
|
self.debug("Adding Egress Network ACL rules in the created VPC "
|
|
"network to allow Source NAT (DNS & HTTP) traffic to the "
|
|
"Internet from the VMs in the network...")
|
|
dns_rule = self.create_NetworkAclRule(
|
|
self.test_data["dns_rule"], traffic_type="Egress",
|
|
network=vpc_tier)
|
|
http_rule = self.create_NetworkAclRule(
|
|
self.test_data["http_rule"], traffic_type="Egress",
|
|
network=vpc_tier)
|
|
|
|
# VSD verification for added Egress Network ACL rules
|
|
self.verify_vsd_firewall_rule(dns_rule, traffic_type="Egress")
|
|
self.verify_vsd_firewall_rule(http_rule, traffic_type="Egress")
|
|
|
|
self.debug("Deploying a VM in the created VPC network...")
|
|
vpc_vm_1 = self.create_VM(vpc_tier)
|
|
self.check_VM_state(vpc_vm_1, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_vm(vpc_vm_1)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(vpc_tier, vpc=vpc)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vpc_vm_1, vpc_tier, vpc=vpc)
|
|
|
|
self.debug("Deploying another VM in the created VPC network...")
|
|
vpc_vm_2 = self.create_VM(vpc_tier)
|
|
self.check_VM_state(vpc_vm_2, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_vm(vpc_vm_2)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(vpc_tier, vpc=vpc)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vpc_vm_2, vpc_tier, vpc=vpc)
|
|
|
|
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
|
|
def test_05_nuage_SourceNAT_acl_rules_traffic(self):
|
|
"""Test Nuage VSP Source NAT functionality with different Egress
|
|
Firewall/Network ACL rules by performing (wget) traffic tests to the
|
|
Internet
|
|
"""
|
|
|
|
# Check if the configured Nuage VSP SDN platform infrastructure
|
|
# supports underlay networking, if not, skip this test.
|
|
# Repeat the tests in the testcases
|
|
# "test_03_nuage_SourceNAT_isolated_network_traffic" and
|
|
# "test_04_nuage_SourceNAT_vpc_network_traffic" with different Egress
|
|
# Firewall/Network ACL rules:
|
|
# 1. Allow and block Egress Firewall rules
|
|
# 2. Allow and block Egress Network ACL rules
|
|
# Verify the above Egress Firewall/Network ACL rules by verifying its
|
|
# Source NAT traffic test (wget www.google.com) to the Internet.
|
|
# Delete all the created objects (cleanup).
|
|
|
|
if not self.isNuageInfraUnderlay:
|
|
self.skipTest("Configured Nuage VSP SDN platform infrastructure "
|
|
"does not support underlay networking: "
|
|
"skipping test")
|
|
|
|
# Creating Isolated network offering
|
|
self.debug("Creating Nuage VSP Isolated Network offering with Source "
|
|
"NAT service provider as NuageVsp...")
|
|
net_off = self.create_NetworkOffering(
|
|
self.test_data["nuagevsp"]["isolated_network_offering"])
|
|
self.validate_NetworkOffering(net_off, state="Enabled")
|
|
|
|
# Creating an Isolated network, deploying a VM, and verifying Source
|
|
# NAT traffic with Egress Firewall rules
|
|
self.debug("Creating an Isolated network with Source NAT service...")
|
|
network = self.create_Network(net_off, gateway='10.1.1.1')
|
|
self.validate_Network(network, state="Allocated")
|
|
|
|
self.debug("Deploying a VM in the created Isolated network...")
|
|
vm = self.create_VM(network)
|
|
self.validate_Network(network, state="Implemented")
|
|
vr = self.get_Router(network)
|
|
self.check_Router_state(vr, state="Running")
|
|
self.check_VM_state(vm, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, network)
|
|
self.verify_vsd_router(vr)
|
|
self.verify_vsd_vm(vm)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm, network)
|
|
|
|
# Adding Egress Firewall rule
|
|
self.debug("Adding an Egress Firewall rule in the created Isolated "
|
|
"network to block/drop Source NAT (DNS) traffic to the "
|
|
"Internet from the VMs in the network...")
|
|
dns_rule_1 = self.create_EgressFirewallRule(
|
|
network, self.test_data["dns_rule"])
|
|
|
|
# VSD verification for added Egress Firewall rule
|
|
self.verify_vsd_firewall_rule(dns_rule_1, traffic_type="Egress")
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
with self.assertRaises(Exception):
|
|
self.verify_SourceNAT_VM_traffic(vm, network, negative_test=True)
|
|
self.debug("Source NAT (DNS) traffic to the Internet from the "
|
|
"deployed VM is blocked/dropped by the added Egress "
|
|
"Firewall rule")
|
|
|
|
# Removing Egress Firewall rule
|
|
self.debug("Removing the added Egress Firewall rule in the created "
|
|
"Isolated network to allow Source NAT (DNS) traffic to "
|
|
"the Internet from the VMs in the network "
|
|
"(Default Egress Firewall rule)...")
|
|
dns_rule_1.delete(self.api_client)
|
|
|
|
# VSD verification for removed Egress Firewall rule
|
|
with self.assertRaises(Exception):
|
|
self.verify_vsd_firewall_rule(dns_rule_1, traffic_type="Egress")
|
|
self.debug("Egress Firewall rule successfully deleted in VSD")
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm, network)
|
|
|
|
# Creating VPC offering
|
|
self.debug("Creating Nuage VSP VPC offering with Source NAT service "
|
|
"provider as NuageVsp...")
|
|
vpc_off = self.create_VpcOffering(
|
|
self.test_data["nuagevsp"]["vpc_offering"])
|
|
self.validate_VpcOffering(vpc_off, state="Enabled")
|
|
|
|
# Creating VPC
|
|
self.debug("Creating a VPC with Source NAT service provider as "
|
|
"NuageVsp...")
|
|
vpc = self.create_Vpc(vpc_off, cidr='10.1.0.0/16')
|
|
self.validate_Vpc(vpc, state="Enabled")
|
|
|
|
# Creating VPC network offering
|
|
self.debug("Creating Nuage VSP VPC Network offering with Source NAT "
|
|
"service provider as NuageVsp...")
|
|
net_off = self.create_NetworkOffering(
|
|
self.test_data["nuagevsp"]["vpc_network_offering"])
|
|
self.validate_NetworkOffering(net_off, state="Enabled")
|
|
|
|
# Creating a VPC network in the VPC, deploying a VM, and verifying
|
|
# Source NAT traffic with Network ACl rules
|
|
self.debug("Creating a VPC network with Source NAT service...")
|
|
vpc_tier = self.create_Network(net_off, gateway='10.1.1.1', vpc=vpc)
|
|
self.validate_Network(vpc_tier, state="Implemented")
|
|
vpc_vr = self.get_Router(vpc_tier)
|
|
self.check_Router_state(vpc_vr, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, vpc_tier, vpc)
|
|
self.verify_vsd_router(vpc_vr)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(vpc_tier, vpc=vpc)
|
|
|
|
# Adding Egress Network ACL rules
|
|
self.debug("Adding Egress Network ACL rules in the created VPC "
|
|
"network to allow Source NAT (DNS & HTTP) traffic to the "
|
|
"Internet from the VMs in the network...")
|
|
dns_rule_2 = self.create_NetworkAclRule(
|
|
self.test_data["dns_rule"], traffic_type="Egress",
|
|
network=vpc_tier)
|
|
http_rule = self.create_NetworkAclRule(
|
|
self.test_data["http_rule"], traffic_type="Egress",
|
|
network=vpc_tier)
|
|
|
|
# VSD verification for added Egress Network ACL rules
|
|
self.verify_vsd_firewall_rule(dns_rule_2, traffic_type="Egress")
|
|
self.verify_vsd_firewall_rule(http_rule, traffic_type="Egress")
|
|
|
|
self.debug("Deploying a VM in the created VPC network...")
|
|
vpc_vm = self.create_VM(vpc_tier)
|
|
self.check_VM_state(vpc_vm, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_vm(vpc_vm)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(vpc_tier, vpc=vpc)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vpc_vm, vpc_tier, vpc=vpc)
|
|
|
|
# Removing Egress Network ACL rule
|
|
self.debug("Removing the added Egress Network ACL rule in the created "
|
|
"VPC network to block Source NAT (DNS) traffic to the "
|
|
"Internet from the VMs in the network "
|
|
"(Default Egress Network ACL rule)...")
|
|
dns_rule_2.delete(self.api_client)
|
|
|
|
# VSD verification for removed Egress Network ACL rule
|
|
with self.assertRaises(Exception):
|
|
self.verify_vsd_firewall_rule(dns_rule_2, traffic_type="Egress")
|
|
self.debug("Egress Network ACL rule successfully deleted in VSD")
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
with self.assertRaises(Exception):
|
|
self.verify_SourceNAT_VM_traffic(vpc_vm, vpc_tier, vpc=vpc,
|
|
negative_test=True)
|
|
self.debug("Source NAT (DNS) traffic to the Internet from the "
|
|
"deployed VM is blocked by the Default Egress Network ACL "
|
|
"rule")
|
|
|
|
# Re-adding Egress Network ACL rule
|
|
self.debug("Re-adding the Egress Network ACL rule in the created VPC "
|
|
"network to allow Source NAT (DNS) traffic to the "
|
|
"Internet from the VMs in the network...")
|
|
dns_rule_2 = self.create_NetworkAclRule(
|
|
self.test_data["dns_rule"], traffic_type="Egress",
|
|
network=vpc_tier)
|
|
|
|
# VSD verification for re-added Egress Network ACL rule
|
|
self.verify_vsd_firewall_rule(dns_rule_2, traffic_type="Egress")
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vpc_vm, vpc_tier, vpc=vpc)
|
|
|
|
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
|
|
def test_06_nuage_SourceNAT_vm_nic_operations_traffic(self):
|
|
"""Test Nuage VSP Source NAT functionality with VM NIC operations by
|
|
performing (wget) traffic tests to the
|
|
Internet
|
|
"""
|
|
|
|
# Check if the configured Nuage VSP SDN platform infrastructure
|
|
# supports underlay networking, if not, skip this test.
|
|
# Repeat the tests in the testcase "test_03_nuage_SourceNAT_isolated_
|
|
# network_traffic" with VM NIC operations:
|
|
# 1. Updating default VM NIC
|
|
# 2. Removing non-default VM NIC
|
|
# 3. Adding and updating default VM NIC
|
|
# Verify the above VM NIC operations by verifying its Source NAT
|
|
# traffic test (wget www.google.com) to the Internet.
|
|
# Delete all the created objects (cleanup).
|
|
|
|
if not self.isNuageInfraUnderlay:
|
|
self.skipTest("Configured Nuage VSP SDN platform infrastructure "
|
|
"does not support underlay networking: "
|
|
"skipping test")
|
|
|
|
# Creating network offering
|
|
self.debug("Creating Nuage VSP Isolated Network offering with Source "
|
|
"NAT service provider as NuageVsp...")
|
|
net_off = self.create_NetworkOffering(
|
|
self.test_data["nuagevsp"]["isolated_network_offering"])
|
|
self.validate_NetworkOffering(net_off, state="Enabled")
|
|
|
|
# Creating Isolated networks, deploying a multi-nic VM, and verifying
|
|
# Source NAT traffic with VM NIC operations
|
|
self.debug("Creating an Isolated network with Source NAT service...")
|
|
network_1 = self.create_Network(net_off, gateway='10.1.1.1')
|
|
self.validate_Network(network_1, state="Allocated")
|
|
|
|
self.debug("Creating another Isolated network with Source NAT "
|
|
"service...")
|
|
network_2 = self.create_Network(net_off, gateway='10.1.2.1')
|
|
self.validate_Network(network_2, state="Allocated")
|
|
|
|
self.debug("Deploying a multi-nic VM in the created Isolated "
|
|
"networks...")
|
|
vm = self.create_VM([network_1, network_2])
|
|
self.validate_Network(network_1, state="Implemented")
|
|
vr_1 = self.get_Router(network_1)
|
|
self.check_Router_state(vr_1, state="Running")
|
|
self.validate_Network(network_2, state="Implemented")
|
|
vr_2 = self.get_Router(network_2)
|
|
self.check_Router_state(vr_2, state="Running")
|
|
self.check_VM_state(vm, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, network_1)
|
|
self.verify_vsd_router(vr_1)
|
|
self.verify_vsd_network(self.domain.id, network_2)
|
|
self.verify_vsd_router(vr_2)
|
|
self.verify_vsd_vm(vm)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network_1)
|
|
self.verify_vsd_SourceNAT_network(network_2)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm, network_1)
|
|
|
|
# Updating default VM NIC
|
|
# This VM NIC operation has no effect on the Source NAT functionality
|
|
self.debug("Updating the default nic of the multi-nic VM...")
|
|
self.nic_operation_VM(vm, network_2, operation="update")
|
|
|
|
# Rebooting (stop - start) VM
|
|
self.debug("Rebooting the multi-nic VM after updating its default nic "
|
|
"for changes to apply to the VM...")
|
|
vm.stop(self.api_client)
|
|
vm.start(self.api_client)
|
|
self.check_VM_state(vm, state="Running")
|
|
|
|
# VSD verification
|
|
updated_vm_info = VirtualMachine.list(self.api_client, id=vm.id)[0]
|
|
self.verify_vsd_vm(updated_vm_info)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network_1)
|
|
self.verify_vsd_SourceNAT_network(network_2)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm, network_2)
|
|
|
|
# Removing non-default VM NIC
|
|
# This VM NIC operation has no effect on the Source NAT functionality
|
|
self.debug("Removing the non-default nic of the multi-nic VM...")
|
|
self.nic_operation_VM(vm, network_1, operation="remove")
|
|
|
|
# Rebooting (stop - start) VM
|
|
self.debug("Rebooting the multi-nic VM after removing its non-default "
|
|
"nic for changes to apply to the VM...")
|
|
vm.stop(self.api_client)
|
|
vm.start(self.api_client)
|
|
self.check_VM_state(vm, state="Running")
|
|
|
|
# VSD verification
|
|
updated_vm_info = VirtualMachine.list(self.api_client, id=vm.id)[0]
|
|
self.verify_vsd_vm(updated_vm_info)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network_1)
|
|
self.verify_vsd_SourceNAT_network(network_2)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm, network_2)
|
|
|
|
# Adding and updating default VM NIC
|
|
# This VM NIC operation has no effect on the Source NAT functionality
|
|
self.debug("Re-adding the non-default nic and updating the default "
|
|
"nic of the multi-nic VM...")
|
|
self.nic_operation_VM(vm, network_1, operation="add")
|
|
self.nic_operation_VM(vm, network_1, operation="update")
|
|
|
|
# Rebooting (stop - start) VM
|
|
self.debug("Rebooting the multi-nic VM after re-adding its "
|
|
"non-default nic for changes to apply to the VM...")
|
|
vm.stop(self.api_client)
|
|
vm.start(self.api_client)
|
|
self.check_VM_state(vm, state="Running")
|
|
|
|
# VSD verification
|
|
updated_vm_info = VirtualMachine.list(self.api_client, id=vm.id)[0]
|
|
self.verify_vsd_vm(updated_vm_info)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network_1)
|
|
self.verify_vsd_SourceNAT_network(network_2)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm, network_1)
|
|
|
|
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
|
|
def test_07_nuage_SourceNAT_vm_migration_traffic(self):
|
|
"""Test Nuage VSP Source NAT functionality with VM migration by
|
|
performing (wget) traffic tests to the Internet
|
|
"""
|
|
|
|
# Check if the configured Nuage VSP SDN platform infrastructure
|
|
# supports underlay networking, if not, skip this test.
|
|
# Repeat the tests in the testcase
|
|
# "test_03_nuage_SourceNAT_isolated_network_traffic" with migration of
|
|
# one of the VMs to another host (if available).
|
|
# Verify the above VM migration by verifying its Source NAT traffic
|
|
# test (wget www.google.com) to the Internet.
|
|
# Delete all the created objects (cleanup).
|
|
|
|
if not self.isNuageInfraUnderlay:
|
|
self.skipTest("Configured Nuage VSP SDN platform infrastructure "
|
|
"does not support underlay networking: "
|
|
"skipping test")
|
|
|
|
# Creating network offering
|
|
self.debug("Creating Nuage VSP Isolated Network offering with Source "
|
|
"NAT service provider as NuageVsp...")
|
|
net_off = self.create_NetworkOffering(
|
|
self.test_data["nuagevsp"]["isolated_network_offering"])
|
|
self.validate_NetworkOffering(net_off, state="Enabled")
|
|
|
|
# Creating an Isolated network, deploying VMs, and verifying Source NAT
|
|
# traffic with VM migrations
|
|
self.debug("Creating an Isolated network with Source NAT service...")
|
|
network = self.create_Network(net_off, gateway='10.1.1.1')
|
|
self.validate_Network(network, state="Allocated")
|
|
|
|
self.debug("Deploying a VM in the created Isolated network...")
|
|
vm_1 = self.create_VM(network)
|
|
self.validate_Network(network, state="Implemented")
|
|
vr = self.get_Router(network)
|
|
self.check_Router_state(vr, state="Running")
|
|
self.check_VM_state(vm_1, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, network)
|
|
self.verify_vsd_router(vr)
|
|
self.verify_vsd_vm(vm_1)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm_1, network)
|
|
|
|
self.debug("Deploying another VM in the created Isolated network...")
|
|
vm_2 = self.create_VM(network)
|
|
self.check_VM_state(vm_2, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_vm(vm_2)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm_2, network)
|
|
|
|
# VM migration
|
|
# This VM migration has no effect on the Source NAT functionality
|
|
self.debug("Migrating one of the VMs in the created Isolated network "
|
|
"to another host, if available...")
|
|
self.migrate_VM(vm_1)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm_1, network)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm_2, network)
|
|
|
|
@attr(tags=["advanced", "nuagevsp"], required_hardware="true")
|
|
def test_08_nuage_SourceNAT_network_restarts_traffic(self):
|
|
"""Test Nuage VSP Source NAT functionality with network restarts by
|
|
performing (wget) traffic tests to the Internet
|
|
"""
|
|
|
|
# Check if the configured Nuage VSP SDN platform infrastructure
|
|
# supports underlay networking, if not, skip this test.
|
|
# Repeat the tests in the testcases
|
|
# "test_03_nuage_SourceNAT_isolated_network_traffic" and
|
|
# "test_04_nuage_SourceNAT_vpc_network_traffic" with network restarts:
|
|
# 1. Restart Isolated Network (cleanup = false)
|
|
# 2. Restart Isolated Network (cleanup = true)
|
|
# 3. Reboot VM in the Isolated Network
|
|
# 4. Restart VPC Network (cleanup = false)
|
|
# 5. Restart VPC Network (cleanup = true)
|
|
# 6. Reboot VM in the VPC Network
|
|
# 7. Restart VPC (cleanup = false)
|
|
# 8. Restart VPC (cleanup = true)
|
|
# Verify the above with network restarts by verifying its Source NAT
|
|
# traffic test (wget www.google.com) to the Internet.
|
|
# Delete all the created objects (cleanup).
|
|
|
|
if not self.isNuageInfraUnderlay:
|
|
self.skipTest("Configured Nuage VSP SDN platform infrastructure "
|
|
"does not support underlay networking: "
|
|
"skipping test")
|
|
|
|
# Creating network offering
|
|
self.debug("Creating Nuage VSP Isolated Network offering with Source "
|
|
"NAT service provider as NuageVsp...")
|
|
net_off = self.create_NetworkOffering(
|
|
self.test_data["nuagevsp"]["isolated_network_offering"])
|
|
self.validate_NetworkOffering(net_off, state="Enabled")
|
|
|
|
# Creating an Isolated network, deploying a VM, and verifying Source
|
|
# NAT traffic with Isolated network restarts
|
|
self.debug("Creating an Isolated network with Source NAT service...")
|
|
network = self.create_Network(net_off, gateway='10.1.1.1')
|
|
self.validate_Network(network, state="Allocated")
|
|
|
|
self.debug("Deploying a VM in the created Isolated network...")
|
|
vm = self.create_VM(network)
|
|
self.validate_Network(network, state="Implemented")
|
|
vr = self.get_Router(network)
|
|
self.check_Router_state(vr, state="Running")
|
|
self.check_VM_state(vm, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, network)
|
|
self.verify_vsd_router(vr)
|
|
self.verify_vsd_vm(vm)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(network)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm, network)
|
|
|
|
# Restarting Isolated network (cleanup = false)
|
|
# VR gets destroyed and deployed again in the Isolated network
|
|
# This restart has no effect on the Source NAT functionality
|
|
self.debug("Restarting the created Isolated network without "
|
|
"cleanup...")
|
|
Network.restart(network, self.api_client, cleanup=False)
|
|
self.validate_Network(network, state="Implemented")
|
|
vr = self.get_Router(network)
|
|
self.check_Router_state(vr, state="Running")
|
|
self.check_VM_state(vm, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, network)
|
|
self.verify_vsd_router(vr)
|
|
self.verify_vsd_vm(vm)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm, network)
|
|
|
|
# Restarting Isolated network (cleanup = true)
|
|
# VR gets destroyed and deployed again in the Isolated network
|
|
# This restart has no effect on the Source NAT functionality
|
|
self.debug("Restarting the created Isolated network with cleanup...")
|
|
Network.restart(network, self.api_client, cleanup=True)
|
|
self.validate_Network(network, state="Implemented")
|
|
vr = self.get_Router(network)
|
|
self.check_Router_state(vr, state="Running")
|
|
self.check_VM_state(vm, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, network)
|
|
self.verify_vsd_router(vr)
|
|
self.verify_vsd_vm(vm)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vm, network)
|
|
|
|
# Creating VPC offering
|
|
self.debug("Creating Nuage VSP VPC offering with Source NAT service "
|
|
"provider as NuageVsp...")
|
|
vpc_off = self.create_VpcOffering(
|
|
self.test_data["nuagevsp"]["vpc_offering"])
|
|
self.validate_VpcOffering(vpc_off, state="Enabled")
|
|
|
|
# Creating VPC
|
|
self.debug("Creating a VPC with Source NAT service provider as "
|
|
"NuageVsp...")
|
|
vpc = self.create_Vpc(vpc_off, cidr='10.1.0.0/16')
|
|
self.validate_Vpc(vpc, state="Enabled")
|
|
|
|
# Creating VPC network offering
|
|
self.debug("Creating Nuage VSP VPC Network offering with Source NAT "
|
|
"service provider as NuageVsp...")
|
|
net_off = self.create_NetworkOffering(
|
|
self.test_data["nuagevsp"]["vpc_network_offering"])
|
|
self.validate_NetworkOffering(net_off, state="Enabled")
|
|
|
|
# Creating a VPC network in the VPC, deploying a VM, and verifying
|
|
# Source NAT traffic with VPC network restarts
|
|
self.debug("Creating a VPC network with Source NAT service...")
|
|
vpc_tier = self.create_Network(net_off, gateway='10.1.1.1', vpc=vpc)
|
|
self.validate_Network(vpc_tier, state="Implemented")
|
|
vpc_vr = self.get_Router(vpc_tier)
|
|
self.check_Router_state(vpc_vr, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, vpc_tier, vpc)
|
|
self.verify_vsd_router(vpc_vr)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(vpc_tier, vpc=vpc)
|
|
|
|
# Adding Egress Network ACL rules
|
|
self.debug("Adding Egress Network ACL rules in the created VPC "
|
|
"network to allow Source NAT (DNS & HTTP) traffic to the "
|
|
"Internet from the VMs in the network...")
|
|
dns_rule = self.create_NetworkAclRule(
|
|
self.test_data["dns_rule"], traffic_type="Egress",
|
|
network=vpc_tier)
|
|
http_rule = self.create_NetworkAclRule(
|
|
self.test_data["http_rule"], traffic_type="Egress",
|
|
network=vpc_tier)
|
|
|
|
# VSD verification for added Egress Network ACL rules
|
|
self.verify_vsd_firewall_rule(dns_rule, traffic_type="Egress")
|
|
self.verify_vsd_firewall_rule(http_rule, traffic_type="Egress")
|
|
|
|
self.debug("Deploying a VM in the created VPC network...")
|
|
vpc_vm = self.create_VM(vpc_tier)
|
|
self.check_VM_state(vpc_vm, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_vm(vpc_vm)
|
|
|
|
# VSD verification for Source NAT functionality
|
|
self.verify_vsd_SourceNAT_network(vpc_tier, vpc=vpc)
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vpc_vm, vpc_tier, vpc=vpc)
|
|
|
|
# Restarting VPC network (cleanup = false)
|
|
# This restart has no effect on the Source NAT functionality
|
|
self.debug("Restarting the created VPC network without cleanup...")
|
|
Network.restart(vpc_tier, self.api_client, cleanup=False)
|
|
self.validate_Network(vpc_tier, state="Implemented")
|
|
self.check_Router_state(vpc_vr, state="Running")
|
|
self.check_VM_state(vpc_vm, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, vpc_tier, vpc)
|
|
self.verify_vsd_router(vpc_vr)
|
|
self.verify_vsd_vm(vpc_vm)
|
|
self.verify_vsd_firewall_rule(dns_rule, traffic_type="Egress")
|
|
self.verify_vsd_firewall_rule(http_rule, traffic_type="Egress")
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vpc_vm, vpc_tier, vpc=vpc)
|
|
|
|
# Restarting VPC network (cleanup = true)
|
|
# This restart has no effect on the Source NAT functionality
|
|
self.debug("Restarting the created VPC network with cleanup...")
|
|
Network.restart(vpc_tier, self.api_client, cleanup=True)
|
|
self.validate_Network(vpc_tier, state="Implemented")
|
|
self.check_Router_state(vpc_vr, state="Running")
|
|
self.check_VM_state(vpc_vm, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, vpc_tier, vpc)
|
|
self.verify_vsd_router(vpc_vr)
|
|
self.verify_vsd_vm(vpc_vm)
|
|
self.verify_vsd_firewall_rule(dns_rule, traffic_type="Egress")
|
|
self.verify_vsd_firewall_rule(http_rule, traffic_type="Egress")
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vpc_vm, vpc_tier, vpc=vpc)
|
|
|
|
# Restarting VPC (cleanup = false)
|
|
# VPC VR gets destroyed and deployed again in the VPC
|
|
# This restart has no effect on the Source NAT functionality
|
|
self.debug("Restarting the VPC without cleanup...")
|
|
self.restart_Vpc(vpc, cleanup=False)
|
|
self.validate_Network(vpc_tier, state="Implemented")
|
|
vpc_vr = self.get_Router(vpc_tier)
|
|
self.check_Router_state(vpc_vr, state="Running")
|
|
self.check_VM_state(vpc_vm, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, vpc_tier, vpc)
|
|
self.verify_vsd_router(vpc_vr)
|
|
self.verify_vsd_vm(vpc_vm)
|
|
self.verify_vsd_firewall_rule(dns_rule, traffic_type="Egress")
|
|
self.verify_vsd_firewall_rule(http_rule, traffic_type="Egress")
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vpc_vm, vpc_tier, vpc=vpc)
|
|
|
|
# Restarting VPC (cleanup = true)
|
|
# VPC VR gets destroyed and deployed again in the VPC
|
|
# This restart has no effect on the Source NAT functionality
|
|
self.debug("Restarting the VPC with cleanup...")
|
|
self.restart_Vpc(vpc, cleanup=True)
|
|
self.validate_Network(vpc_tier, state="Implemented")
|
|
vpc_vr = self.get_Router(vpc_tier)
|
|
self.check_Router_state(vpc_vr, state="Running")
|
|
self.check_VM_state(vpc_vm, state="Running")
|
|
|
|
# VSD verification
|
|
self.verify_vsd_network(self.domain.id, vpc_tier, vpc)
|
|
self.verify_vsd_router(vpc_vr)
|
|
self.verify_vsd_vm(vpc_vm)
|
|
self.verify_vsd_firewall_rule(dns_rule, traffic_type="Egress")
|
|
self.verify_vsd_firewall_rule(http_rule, traffic_type="Egress")
|
|
|
|
# Verifying Source NAT traffic (wget www.google.com) to the Internet
|
|
# from the deployed VM. This Source NAT traffic test is done through a
|
|
# custom init script in the guest VM template upon the VM boot up.
|
|
self.verify_SourceNAT_VM_traffic(vpc_vm, vpc_tier, vpc=vpc)
|