def _verify_l3_subnet(self, vsd_api_subnet, vspk_subnet, vspk_backend_subnet=None, with_enterprise=True): # The backend subnet is only relevant when the l3 subnet is linked # to a backend subnet in Shared Infrastructure. openstack_2913_bug_applies = (vspk_backend_subnet and Topology.before_nuage('6.0')) vspk_backend_subnet = vspk_backend_subnet or vspk_subnet self.assertEqual(vspk_subnet.id, vsd_api_subnet.get('id')) self.assertEqual(vspk_subnet.name, vsd_api_subnet.get('name')) if vspk_backend_subnet.address: cidr = IPNetwork(vspk_backend_subnet.address + '/' + vspk_backend_subnet.netmask) self.assertEqual(str(cidr), vsd_api_subnet.get('cidr')) else: self.assertIsNone(vsd_api_subnet.get('cidr')) self.assertEqual(vspk_backend_subnet.ipv6_address, vsd_api_subnet.get('ipv6_cidr')) if not openstack_2913_bug_applies: self.assertEqual(vspk_backend_subnet.gateway, vsd_api_subnet.get('gateway')) self.assertEqual(vspk_backend_subnet.ipv6_gateway, vsd_api_subnet.get('ipv6_gateway')) self.assertEqual(vspk_backend_subnet.ip_type, vsd_api_subnet.get('ip_version')) if with_enterprise: self.assertEqual(self.vsd.get_default_enterprise().name, vsd_api_subnet.get('net_partition'))
def _setup_resources_vsd_mgd(self, is_l3=True, ip_version=(4,)): self._create_vsd_domain(is_l3=is_l3, ip_version=ip_version) domain = self.domain if is_l3 else self.l2domain pg_name = tempest_data_utils.rand_name('pg-') self.vsd.create_policy_group(domain, name=pg_name) allow_ipv4 = 4 in ip_version allow_ipv6 = 6 in ip_version self.vsd.define_any_to_any_acl(domain, allow_ipv4=allow_ipv4, allow_ipv6=allow_ipv6, stateful=True) self.network = self.create_network( manager=self.admin_manager, tenant_id=self.manager.networks_client.tenant_id, **NETWORK_ARGS) if is_l3: vsd_subnet = self.l3subnet create_vsd_managed_subnet = self.create_l3_vsd_managed_subnet else: vsd_subnet = self.l2domain create_vsd_managed_subnet = self.create_l2_vsd_managed_subnet self.subnet = [] for ip_type in ip_version: self.subnet.append(create_vsd_managed_subnet( self.network, vsd_subnet, ip_version=ip_type, manager=self.admin_manager, dhcp_managed=Topology.before_nuage('6.0'))) self.secgroup = self.create_open_ssh_security_group( manager=self.admin_manager)
def skip_checks(cls): super(NuageHybridMplsTest, cls).skip_checks() if Topology.before_nuage('20.5'): raise cls.skipException('nuage_hybrid_mpls is supported from ' '20.5 onwards only') if not CONF.nuage_sut.nuage_hybrid_mpls_enabled: raise cls.skipException('nuage_hybrid_mpls type driver ' 'not enabled in tempest.conf')
def skip_checks(cls): super(NuageHybridMplsSriovTest, cls).skip_checks() if Topology.before_nuage('20.5'): raise cls.skipException('nuage_hybrid_mpls is supported from ' '20.5 onwards only') if not CONF.nuage_sut.nuage_hybrid_mpls_enabled: raise cls.skipException('nuage_hybrid_mpls type driver ' 'not enabled in tempest.conf') if CONF.network.port_vnic_type not in ['direct', 'macvtap']: msg = ("Test requires nuage_test_sriov mech driver " "and port_vnic_type=='direct'") raise cls.skipException(msg)
def _create_vsd_domain(self, is_l3=True, ip_version=(4,)): cidr4 = None cidr6 = None enable_dhcpv4 = enable_dhcpv6 = Topology.before_nuage('6.0') gateway4 = None gateway6 = None for ip_type in ip_version: if ip_type == 4: cidr4 = data_utils.gimme_a_cidr(ip_type) gateway4 = str(cidr4[1]) if is_l3 else None elif ip_type == 6: cidr6 = data_utils.gimme_a_cidr(ip_type) gateway6 = str(cidr6[1]) if is_l3 else None kwargs = {} if CONF.nuage_sut.gateway_type == 'cisco': kwargs['ingress_replication_enabled'] = True if is_l3: l3template = self.vsd_create_l3domain_template() self.domain = self.vsd_create_l3domain(template_id=l3template.id) zone = self.vsd_create_zone(domain=self.domain) self.l3subnet = self.create_vsd_subnet( zone=zone, cidr4=cidr4, cidr6=cidr6, enable_dhcpv4=enable_dhcpv4, enable_dhcpv6=enable_dhcpv6, gateway4=gateway4, gateway6=gateway6, ip_type=self.ip_types[ip_version], **kwargs ) else: l2template = self.vsd_create_l2domain_template( cidr4=cidr4, cidr6=cidr6, enable_dhcpv4=enable_dhcpv4, enable_dhcpv6=enable_dhcpv6, ip_type=self.ip_types[ip_version], ) self.l2domain = self.vsd_create_l2domain(template=l2template, **kwargs)
def skip_checks(cls): super(TestNuageRouterOSMgdAggregateFlows, cls).skip_checks() if Topology.before_nuage('20.5'): raise cls.skipException('OS managed aggregate flows are ' 'unavailable before 20.5')
class NuageFipToVip(NuageBaseTest): @decorators.attr(type='smoke') def test_fip2vip_when_fip_preexists(self): # Base resources network = self.create_network() self.assertIsNotNone(network, "Unable to create network") subnet = self.create_subnet(network) self.assertIsNotNone(subnet, "Unable to create subnet") router = self.create_router(admin_state_up=True, external_network_id=self.ext_net_id) self.assertIsNotNone(router, "Unable to create router") self.router_attach(router, subnet) # Create VIP_port vip_port = self.create_port(network=network, device_owner="nuage:vip") self.assertIsNotNone(vip_port, "Unable to create vip port") # Create floating ip and attach to VIP_PORT floating_ip = self.create_floatingip() self.assertIsNotNone(floating_ip, "Unable to create floating ip") self.update_floatingip(floatingip=floating_ip, port_id=vip_port['id']) # Create Port with AAP of VIP Port vport = self.create_port(network=network) self.assertIsNotNone(vport, "Unable to create port") # Add Allowable_address_pair to port, this should result in the # floating ip attaching to the virtual ip on VSD. aap_ip = vip_port['fixed_ips'][0]['ip_address'] aap_mac = vport['mac_address'] self.update_port(port=vport, allowed_address_pairs=[{ "ip_address": aap_ip, "mac_address": aap_mac }]) # Check VSD status nuage_vip = self.vsd.get_vport_vip(vport_id=vport['id'], router_id=router['id']) self.assertIsNotNone(nuage_vip, "Not able to find VIP on VSD.") self.assertIsNotNone(nuage_vip.associated_floating_ip_id, "No floating ip associated to the VIP port") @decorators.attr(type='smoke') def test_fip_to_vip_on_non_vip_port(self): # Referencing OPENSTACK-2141 network = self.create_network() self.assertIsNotNone(network, "Unable to create network") subnet = self.create_subnet(network) self.assertIsNotNone(subnet, "Unable to create subnet") router = self.create_router(admin_state_up=True, external_network_id=self.ext_net_id) self.assertIsNotNone(router, "Unable to create router") self.router_attach(router, subnet) # Create VIP_port # VIP port is wrongly created without appropriate device owner vip_port = self.create_port(network=network) self.assertIsNotNone(vip_port, "Unable to create vip port") # Create Port with AAP of VIP Port AAP_port = self.create_port(network=network) self.assertIsNotNone(AAP_port, "Unable to create port") # Add Allowable_address_pair to port, this should result in the # VIP creation on VSD. # If nuage_vsd_managed ipam driver is enabled this will fail, as # nuage:vip port is required in this case. aap_ip = vip_port['fixed_ips'][0]['ip_address'] aap_mac = AAP_port['mac_address'] if CONF.nuage_sut.ipam_driver == 'nuage_vsd_managed': self.assertRaisesRegex(exceptions.BadRequest, "Unable to find 'vip' reservation port for " "allowed address pair with ip", self.update_port, port=AAP_port, allowed_address_pairs=[{ "ip_address": aap_ip, "mac_address": aap_mac }]) return self.update_port(port=AAP_port, allowed_address_pairs=[{ "ip_address": aap_ip, "mac_address": aap_mac }]) # Create floating ip and attach to VIP_PORT floating_ip = self.create_floatingip() self.assertIsNotNone(floating_ip, "Unable to create floating ip") self.update_floatingip(floatingip=floating_ip, port_id=vip_port['id']) # Check VSD status nuage_vip = self.vsd.get_vport_vip(vport_id=AAP_port['id'], router_id=router['id']) self.assertIsNotNone(nuage_vip, "Not able to find VIP on VSD.") self.assertIsNone( nuage_vip.associated_floating_ip_id, "Floating ip associated with port that does not" "have the correct device owner.") # Assert FIP associated to vport for fake vip neutron port vsd_subnet = self.vsd.get_subnet_from_domain(by_subnet=subnet) nuage_vport_for_fake_vip = self.vsd.get_vport( subnet=vsd_subnet, by_port_id=vip_port['id']) self.assertIsNotNone( nuage_vport_for_fake_vip.associated_floating_ip_id, "Floating ip not correctly attached to fake nuage_vip port.") # disassociate fip self.update_floatingip(floatingip=floating_ip, port_id=None) # Assert FIP disassociated nuage_vip = self.vsd.get_vport_vip(vport_id=AAP_port['id'], router_id=router['id']) self.assertIsNotNone(nuage_vip, "Not able to find VIP on VSD.") self.assertIsNone( nuage_vip.associated_floating_ip_id, "Floating ip associated with port that does not " "have the correct device owner.") nuage_vport_for_fake_vip = self.vsd.get_vport( subnet=vsd_subnet, by_port_id=vip_port['id']) self.assertIsNone( nuage_vport_for_fake_vip.associated_floating_ip_id, "Floating ip not correctly detached from fake nuage_vip port.") # Assert FIP as available self.update_floatingip(floatingip=floating_ip, port_id=AAP_port['id']) nuage_vport = self.vsd.get_vport(subnet=vsd_subnet, by_port_id=AAP_port['id']) self.assertIsNotNone( nuage_vport.associated_floating_ip_id, "Floating ip not correctly attached to the vport.") @decorators.attr(type='smoke') def test_fip2vip_dualstack_port(self): # openstack-2192 network = self.create_network() self.assertIsNotNone(network, "Unable to create network") subnet = self.create_subnet(network, cidr=IPNetwork("99.0.0.0/24"), mask_bits=24) self.assertIsNotNone(subnet, "Unable to create subnet") subnet2 = self.create_subnet(network, cidr=IPNetwork("1::/64"), mask_bits=64, ip_version=6) router = self.create_router(admin_state_up=True, external_network_id=self.ext_net_id) self.assertIsNotNone(router, "Unable to create router") self.router_attach(router, subnet) self.router_attach(router, subnet2) # Create VIP_port vip_port = self.create_port(network=network, device_owner="nuage:vip") self.assertIsNotNone(vip_port, "Unable to create vip port") # Create Port with AAP of VIP Port vport = self.create_port(network=network) self.assertIsNotNone(vport, "Unable to create port") # Add Allowable_address_pair to port aap1 = vip_port['fixed_ips'][0] aap2 = vip_port['fixed_ips'][1] aap_mac = vport['mac_address'] if aap1['subnet_id'] == subnet['id']: aap = {"ip_address": aap1['ip_address'], "mac_address": aap_mac} else: aap = {"ip_address": aap2['ip_address'], "mac_address": aap_mac} self.update_port(port=vport, allowed_address_pairs=[aap]) # Create floating ip and attach to VIP_PORT floating_ip = self.create_floatingip(cleanup=False) self.assertIsNotNone(floating_ip, "Unable to create floating ip") self.update_floatingip(floatingip=floating_ip, port_id=vip_port['id']) # Check VSD status nuage_vip = self.vsd.get_vport_vip(vport_id=vport['id'], router_id=router['id']) self.assertIsNotNone(nuage_vip, "Not able to find VIP on VSD.") self.assertIsNotNone(nuage_vip.associated_floating_ip_id, "No floating ip associated to the VIP port") # Delete floating ip self.delete_floatingip(floating_ip['id']) nuage_vip = self.vsd.get_vport_vip(vport_id=vport['id'], router_id=router['id']) self.assertIsNotNone(nuage_vip, "Not able to find VIP on VSD.") self.assertIsNone( nuage_vip.associated_floating_ip_id, "No floating ip should be associated to the " "VIP port after floating ip delete.") @decorators.attr(type='smoke') def test_fip2vip_dualstack_port_with_fip_first_then_vip(self): # openstack-2192 network = self.create_network() self.assertIsNotNone(network, "Unable to create network") subnet = self.create_subnet(network, cidr=IPNetwork("99.0.0.0/24"), mask_bits=24) self.assertIsNotNone(subnet, "Unable to create subnet") subnet2 = self.create_subnet(network, cidr=IPNetwork("1::/64"), mask_bits=64, ip_version=6) router = self.create_router(admin_state_up=True, external_network_id=self.ext_net_id) self.assertIsNotNone(router, "Unable to create router") self.router_attach(router, subnet) self.router_attach(router, subnet2) # Create VIP_port vip_port = self.create_port(network=network, device_owner="nuage:vip") self.assertIsNotNone(vip_port, "Unable to create vip port") # Create floating ip and attach to VIP_PORT floating_ip = self.create_floatingip(cleanup=False) self.assertIsNotNone(floating_ip, "Unable to create floating ip") self.update_floatingip(floatingip=floating_ip, port_id=vip_port['id']) # Create Port with AAP of VIP Port vport = self.create_port(network=network) self.assertIsNotNone(vport, "Unable to create port") # Add Allowable_address_pair to port aap1 = vip_port['fixed_ips'][0] aap2 = vip_port['fixed_ips'][1] aap_mac = vport['mac_address'] if aap1['subnet_id'] == subnet['id']: aap = {"ip_address": aap1['ip_address'], "mac_address": aap_mac} else: aap = {"ip_address": aap2['ip_address'], "mac_address": aap_mac} self.update_port(port=vport, allowed_address_pairs=[aap]) # Check VSD status nuage_vip = self.vsd.get_vport_vip(vport_id=vport['id'], router_id=router['id']) self.assertIsNotNone(nuage_vip, "Not able to find VIP on VSD.") self.assertIsNotNone(nuage_vip.associated_floating_ip_id, "No floating ip associated to the VIP port") # Delete floating ip self.delete_floatingip(floating_ip['id']) nuage_vip = self.vsd.get_vport_vip(vport_id=vport['id'], router_id=router['id']) self.assertIsNotNone(nuage_vip, "Not able to find VIP on VSD.") self.assertIsNone( nuage_vip.associated_floating_ip_id, "No floating ip should be associated to the " "VIP port after floating ip delete.") @decorators.attr(type='smoke') def test_fip_to_vip_delete_nuage_vip_port_disassociate(self): # Referencing OPENSTACK-2202 network = self.create_network() self.assertIsNotNone(network, "Unable to create network") subnet = self.create_subnet(network) self.assertIsNotNone(subnet, "Unable to create subnet") router = self.create_router(admin_state_up=True, external_network_id=self.ext_net_id) self.assertIsNotNone(router, "Unable to create router") self.router_attach(router, subnet) # Create VIP_port vip_port = self.create_port(network=network, device_owner="nuage:vip", cleanup=False) self.assertIsNotNone(vip_port, "Unable to create vip port") # Create Port with AAP of VIP Port AAP_port = self.create_port(network=network) self.assertIsNotNone(AAP_port, "Unable to create port") # Add Allowable_address_pair to port, this should result in the # VIP creation on VSD. aap_ip = vip_port['fixed_ips'][0]['ip_address'] aap_mac = AAP_port['mac_address'] self.update_port(port=AAP_port, allowed_address_pairs=[{ "ip_address": aap_ip, "mac_address": aap_mac }]) # Create floating ip and attach to VIP_PORT floating_ip = self.create_floatingip() self.assertIsNotNone(floating_ip, "Unable to create floating ip") self.update_floatingip(floatingip=floating_ip, port_id=vip_port['id']) # Check VSD status nuage_vip = self.vsd.get_vport_vip(vport_id=AAP_port['id'], router_id=router['id']) self.assertIsNotNone(nuage_vip, "Not able to find VIP on VSD.") self.assertIsNotNone(nuage_vip.associated_floating_ip_id, "Floating ip not associated with vip.") # Delete nuage:fip port self.delete_port(vip_port) # Assert FIP disassociated nuage_vip = self.vsd.get_vport_vip(vport_id=AAP_port['id'], router_id=router['id']) self.assertIsNotNone(nuage_vip, "Not able to find VIP on VSD.") self.assertIsNone(nuage_vip.associated_floating_ip_id, "Floating ip still associated to vip.") # Assert FIP as available self.update_floatingip(floatingip=floating_ip, port_id=AAP_port['id']) vsd_subnet = self.vsd.get_subnet_from_domain(by_subnet=subnet) nuage_vport = self.vsd.get_vport(subnet=vsd_subnet, by_port_id=AAP_port['id']) self.assertIsNotNone( nuage_vport.associated_floating_ip_id, "Floating ip not correctly attached to the vport.") @decorators.attr(type='smoke') def test_fip_to_vip_with_vm(self): network = self.create_network() self.assertIsNotNone(network, "Unable to create network") subnet = self.create_subnet(network) self.assertIsNotNone(subnet, "Unable to create subnet") router = self.create_router(external_network_id=self.ext_net_id) self.assertIsNotNone(router, "Unable to create router") self.router_attach(router, subnet) # Create VIP_port vip_port = self.create_port(network=network, device_owner="nuage:vip") self.assertIsNotNone(vip_port, "Unable to create vip port") # Create Port with AAP of VIP Port AAP_port = self.create_port(network=network) self.assertIsNotNone(AAP_port, "Unable to create port") # Add Allowable_address_pair to port, this should result in the # VIP creation on VSD. aap_ip = vip_port['fixed_ips'][0]['ip_address'] aap_mac = AAP_port['mac_address'] self.update_port(port=AAP_port, allowed_address_pairs=[{ "ip_address": aap_ip, "mac_address": aap_mac }]) # Create server on port self.create_tenant_server(ports=[AAP_port]) # Create floating ip and attach to VIP_PORT floating_ip = self.create_floatingip() self.assertIsNotNone(floating_ip, "Unable to create floating ip") self.update_floatingip(floatingip=floating_ip, port_id=vip_port['id']) # Check VSD status nuage_vip = self.vsd.get_vport_vip(vport_id=AAP_port['id'], router_id=router['id']) self.assertIsNotNone(nuage_vip, "Not able to find VIP on VSD.") self.assertIsNotNone(nuage_vip.associated_floating_ip_id, "Floating ip not associated with vip.") @decorators.attr(type='smoke') @testtools.skipIf(Topology.before_nuage('20.5'), 'OPENSTACK-2912 fixed as of 20.5 only.') def test_fip_to_vip_when_previously_assigned(self): network = self.create_network() self.assertIsNotNone(network, "Unable to create network") subnet = self.create_subnet(network) self.assertIsNotNone(subnet, "Unable to create subnet") router = self.create_router(external_network_id=self.ext_net_id) self.assertIsNotNone(router, "Unable to create router") self.router_attach(router, subnet) # Create VIP_port vip_port = self.create_port(network=network, device_owner="nuage:vip") self.assertIsNotNone(vip_port, "Unable to create vip port") # Create Port with AAP of VIP Port AAP_port = self.create_port(network=network) self.assertIsNotNone(AAP_port, "Unable to create port") # Add Allowable_address_pair to port, this should result in the # VIP creation on VSD. aap_ip = vip_port['fixed_ips'][0]['ip_address'] aap_mac = AAP_port['mac_address'] self.update_port(port=AAP_port, allowed_address_pairs=[{ "ip_address": aap_ip, "mac_address": aap_mac }]) # Create floating ip and attach to non-vip port floating_ip = self.create_floatingip() self.assertIsNotNone(floating_ip, "Unable to create floating ip") self.update_floatingip(floatingip=floating_ip, port_id=AAP_port['id']) # Update floating ip to be attached to vip port self.update_floatingip(floatingip=floating_ip, port_id=vip_port['id']) # Check VSD status nuage_vip = self.vsd.get_vport_vip(vport_id=AAP_port['id'], router_id=router['id']) self.assertIsNotNone(nuage_vip, "Not able to find VIP on VSD.") self.assertIsNotNone(nuage_vip.associated_floating_ip_id, "Floating ip not associated with vip.")
def test_update_floatingip_with_rate_limit_minimal_value(self): fip = self._create_fip_with_fip_rate_limit(self.ports[0], 2000, 5000) if Topology.before_nuage('20.10'): self._update_fip_with_fip_rate_limit(self.ports[0], fip, 0, 0) else: self._update_fip_with_fip_rate_limit(self.ports[0], fip, 1, 1)
def test_create_floatingip_with_rate_limit_minimal_value(self): if Topology.before_nuage('20.10'): self._create_fip_with_fip_rate_limit(self.ports[0], '0', '0') else: self._create_fip_with_fip_rate_limit(self.ports[0], '1', '1')
def skip_checks(cls): super(OsMgdL3ConnectivityTestWithAggrFlowsTest, cls).skip_checks() if Topology.before_nuage('20.5'): raise cls.skipException('OS managed aggregate flows are ' 'unavailable before 20.5')
class SriovBasicOpsTest(NuageBaseTest): force_tenant_isolation = False ip_types = {(4,): 'IPV4', (6,): 'IPV6', (4, 6): 'DUALSTACK'} @classmethod def resource_setup(cls): super(SriovBasicOpsTest, cls).resource_setup() cls.aggregates = cls.admin_manager.aggregates_client.list_aggregates() cls.hosts_vrs = [aggregate['hosts'] for aggregate in cls.aggregates['aggregates'] if aggregate['metadata']['flavor'] == 'vrs'][0] cls.hosts_sriov = [aggregate['hosts'] for aggregate in cls.aggregates['aggregates'] if aggregate['metadata']['flavor'] == 'sriov'][0] cls.availability_zones_vrs = ['nova:' + host for host in cls.hosts_vrs] cls.availability_zones_sriov = ['nova:' + host for host in cls.hosts_sriov] @classmethod def skip_checks(cls): super(SriovBasicOpsTest, cls).skip_checks() if CONF.network.port_vnic_type not in ['direct']: msg = 'Test requires port_vnic_type "direct"' raise cls.skipException(msg) if Topology.has_default_switchdev_port_profile(): raise cls.skipException('Test requires switchdev offloading ' 'to be disabled') def _check_connectivity(self, ip_version=4): connectivity_check_pairs = [] sriov_compute = self.availability_zones_sriov[0] server_to = self._create_server_with_direct_port( availability_zone=sriov_compute) vrs_computes = [sriov_compute] if any(self.availability_zones_vrs): vrs_computes.append(self.availability_zones_vrs[0]) for availability_zone in vrs_computes: server_from = self._create_server_with_virtio_port( availability_zone=availability_zone) connectivity_check_pairs.append((server_from, server_to)) for server_from, server_to in connectivity_check_pairs: self.assert_ping( server_from['server'], ip_version=ip_version, address=server_to['port']['fixed_ips'][0]['ip_address']) def _create_server_with_virtio_port(self, availability_zone): port = self.create_port(self.network, security_groups=[ self.secgroup['id']], manager=self.admin_manager, **VIRTIO_ARGS) server = self.create_tenant_server( availability_zone=availability_zone, ports=[port], prepare_for_connectivity=True, manager=self.admin_manager) return {'port': port, 'server': server} def _create_server_with_direct_port(self, availability_zone): kwargs = {'config_drive': True} port = self.create_port(self.network, port_security_enabled=False, manager=self.admin_manager) server = self.create_tenant_server( availability_zone=availability_zone, ports=[port], prepare_for_connectivity=False, # explicit, as must be manager=self.admin_manager, **kwargs) return {'port': port, 'server': server} def _create_vsd_domain(self, is_l3=True, ip_version=(4,)): cidr4 = None cidr6 = None enable_dhcpv4 = False enable_dhcpv6 = False gateway4 = None gateway6 = None for ip_type in ip_version: if ip_type == 4: cidr4 = data_utils.gimme_a_cidr(ip_type) gateway4 = str(cidr4[1]) if is_l3 else None elif ip_type == 6: cidr6 = data_utils.gimme_a_cidr(ip_type) gateway6 = str(cidr6[1]) if is_l3 else None kwargs = {} if CONF.nuage_sut.gateway_type == 'cisco': kwargs['ingress_replication_enabled'] = True if is_l3: l3template = self.vsd_create_l3domain_template() self.domain = self.vsd_create_l3domain(template_id=l3template.id) zone = self.vsd_create_zone(domain=self.domain) self.l3subnet = self.create_vsd_subnet( zone=zone, cidr4=cidr4, cidr6=cidr6, enable_dhcpv4=enable_dhcpv4, enable_dhcpv6=enable_dhcpv6, gateway4=gateway4, gateway6=gateway6, ip_type=self.ip_types[ip_version], **kwargs ) else: l2template = self.vsd_create_l2domain_template( cidr4=cidr4, cidr6=cidr6, enable_dhcpv4=enable_dhcpv4, enable_dhcpv6=enable_dhcpv6, ip_type=self.ip_types[ip_version], ) self.l2domain = self.vsd_create_l2domain(template=l2template, **kwargs) def _setup_resources_vsd_mgd(self, is_l3=True, ip_version=(4,)): self._create_vsd_domain(is_l3=is_l3, ip_version=ip_version) domain = self.domain if is_l3 else self.l2domain pg_name = tempest_data_utils.rand_name('pg-') self.vsd.create_policy_group(domain, name=pg_name) allow_ipv4 = 4 in ip_version allow_ipv6 = 6 in ip_version self.vsd.define_any_to_any_acl(domain, allow_ipv4=allow_ipv4, allow_ipv6=allow_ipv6, stateful=True) self.network = self.create_network( manager=self.admin_manager, tenant_id=self.manager.networks_client.tenant_id, **NETWORK_ARGS) if is_l3: vsd_subnet = self.l3subnet create_vsd_managed_subnet = self.create_l3_vsd_managed_subnet else: vsd_subnet = self.l2domain create_vsd_managed_subnet = self.create_l2_vsd_managed_subnet self.subnet = [] for ip_type in ip_version: self.subnet.append(create_vsd_managed_subnet( self.network, vsd_subnet, ip_version=ip_type, manager=self.admin_manager, dhcp_managed=False)) self.secgroup = self.create_open_ssh_security_group( manager=self.admin_manager) def _setup_resources(self, is_l3=True, ip_version=(4,)): # setup basic topology for servers we can log into self.network = self.create_network( manager=self.admin_manager, tenant_id=self.manager.networks_client.tenant_id, **NETWORK_ARGS) self.subnet = [] for ip_type in ip_version: self.subnet.append(self.create_subnet(self.network, ip_version=ip_type, manager=self.admin_manager, enable_dhcp=False)) if is_l3: router = self.create_public_router(manager=self.admin_manager) for subnet in self.subnet: self.router_attach(router, subnet, manager=self.admin_manager) self.secgroup = self.create_open_ssh_security_group( manager=self.admin_manager) def test_server_connectivity_l3(self): self._setup_resources() self._check_connectivity() def test_server_connectivity_l2(self): self._setup_resources(is_l3=False) self._check_connectivity() @nuage_test.skip_because( condition=Topology.before_nuage('6.0')) def test_server_connectivity_l3_ipv6(self): self._setup_resources(ip_version=(6,)) self._check_connectivity(ip_version=6) @nuage_test.skip_because( condition=Topology.before_nuage('6.0')) def test_server_connectivity_l2_ipv6(self): self._setup_resources(is_l3=False, ip_version=(6,)) self._check_connectivity(ip_version=6) def test_server_connectivity_l3_dual(self): self._setup_resources(ip_version=(4, 6)) self._check_connectivity() def test_server_connectivity_l2_dual(self): self._setup_resources(is_l3=False, ip_version=(4, 6)) self._check_connectivity() def test_server_connectivity_l3_vsd_mgd(self): self._setup_resources_vsd_mgd() self._check_connectivity() def test_server_connectivity_l2_vsd_mgd(self): self._setup_resources_vsd_mgd(is_l3=False) self._check_connectivity() @nuage_test.skip_because( condition=Topology.before_nuage('6.0')) def test_server_connectivity_l3_ipv6_vsd_mgd(self): self._setup_resources_vsd_mgd(ip_version=(6,)) self._check_connectivity(ip_version=6) @nuage_test.skip_because( condition=Topology.before_nuage('6.0')) def test_server_connectivity_l2_ipv6_vsd_mgd(self): self._setup_resources_vsd_mgd(is_l3=False, ip_version=(6,)) self._check_connectivity(ip_version=6) def test_server_connectivity_l3_dual_vsd_mgd(self): self._setup_resources_vsd_mgd(ip_version=(4, 6)) self._check_connectivity() def test_server_connectivity_l2_dual_vsd_mgd(self): self._setup_resources_vsd_mgd(is_l3=False, ip_version=(4, 6)) self._check_connectivity()
class NuageFloatingIPProprietaryQosTest( test_floatingip.FloatingIpTestCasesMixin, base_nuage_qos.NuageQoSTestMixin, neutron_base.BaseTempestTestCase): same_network = True @classmethod @utils.requires_ext(extension="router", service="network") def resource_setup(cls): super(NuageFloatingIPProprietaryQosTest, cls).resource_setup() @testtools.skipIf(Topology.before_nuage('20.10'), 'VRS-47436') def test_qos(self): """Test floating IP is binding to a QoS policy with ingress and egress bandwidth limit rules. And it applied correctly by sending a file from the instance to the test node. Then calculating the bandwidth every ~1 sec by the number of bits received / elapsed time. """ self._test_basic_resources() ssh_client = self._create_ssh_client() fip = self.os_admin.network_client.get_floatingip( self.fip['id'])['floatingip'] self.assertEqual(self.port['id'], fip['port_id']) if hasattr(self, 'FILE_SIZE'): # Queens & Rocky: create file self._create_file_for_bw_tests(ssh_client) # Check bw not limited unlimited_bw = sys.maxsize common_utils.wait_until_true( lambda: self._check_bw(ssh_client, self.fip['floating_ip_address'], port=self.NC_PORT, expected_bw=unlimited_bw), timeout=240) self.os_admin.network_client.update_floatingip( self.fip['id'], nuage_egress_fip_rate_kbps=500, nuage_ingress_fip_rate_kbps=1000) expected_egress_bw = 500 * 1024 * self.TOLERANCE_FACTOR / 8.0 expected_ingress_bw = 1000 * 1024 * self.TOLERANCE_FACTOR / 8.0 common_utils.wait_until_true( lambda: self._check_bw(ssh_client, self.fip['floating_ip_address'], port=self.NC_PORT, expected_bw=expected_egress_bw), timeout=120, sleep=1) common_utils.wait_until_true( lambda: self._check_bw_ingress(ssh_client, self.fip['floating_ip_address'], port=self.NC_PORT + 1, expected_bw=expected_ingress_bw), timeout=120, sleep=1) # Update floating ip QOS to new value self.os_admin.network_client.update_floatingip( self.fip['id'], nuage_egress_fip_rate_kbps=200, nuage_ingress_fip_rate_kbps=400) expected_egress_bw = 200 * 1024 * self.TOLERANCE_FACTOR / 8.0 expected_ingress_bw = 400 * 1024 * self.TOLERANCE_FACTOR / 8.0 common_utils.wait_until_true( lambda: self._check_bw(ssh_client, self.fip['floating_ip_address'], port=self.NC_PORT, expected_bw=expected_egress_bw), timeout=120, sleep=1) common_utils.wait_until_true( lambda: self._check_bw_ingress(ssh_client, self.fip['floating_ip_address'], port=self.NC_PORT + 1, expected_bw=expected_ingress_bw), timeout=120, sleep=1)