# 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)