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)
