x/vmware-nsx-tempest-plugin
Code Issues Proposed changes

[Tempest]: Added api/scenario cases for vlan backed tier-1.

Browse Source 
Added api cases
Added sceanrio cases

Change-Id: Ie9cefe07e8efc4e409c25092897df54a7f6f2650
This commit is contained in:
Puneet Arora 2018-03-14 00:25:54 +00:00
parent 1cbe4c9259
commit 5cd98ba2f3
5 changed files with 494 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vmware_nsx_tempest/common/constants.py
View File

@ -65,7 +65,7 @@ TIME = {"SEC": {"SIXTY": 60}}
VLAN_TYPE = 'vlan'
VXLAN_TYPE = 'geneve'
VLAN = 1001
VLAN = 2099
NO_OF_VMS_2 = 2
NO_OF_VMS_4 = 4

34
vmware_nsx_tempest/lib/appliance_manager.py
View File

@ -95,7 +95,7 @@ class ApplianceManager(manager.NetworkScenarioTest):
return self.topology_keypairs[server['key_name']]['private_key']
def create_topology_router(self, router_name, routers_client=None,
tenant_id=None, **kwargs):
tenant_id=None, set_gateway=True, **kwargs):
if not routers_client:
routers_client = self.routers_client
if not tenant_id:
@ -104,11 +104,12 @@ class ApplianceManager(manager.NetworkScenarioTest):
name = data_utils.rand_name(router_name_)
router = routers_client.create_router(
name=name, admin_state_up=True, tenant_id=tenant_id)['router']
public_network_info = {"external_gateway_info": dict(
network_id=self.topology_public_network_id)}
routers_client.update_router(router['id'], **public_network_info)
if set_gateway is not False:
public_network_info = {"external_gateway_info": dict(
network_id=self.topology_public_network_id)}
routers_client.update_router(router['id'], **public_network_info)
self.topology_routers[router_name] = router
self.addCleanup(self.routers_client.delete_router, router['id'])
self.addCleanup(routers_client.delete_router, router['id'])
return router
def create_topology_network(
@ -255,6 +256,23 @@ class ApplianceManager(manager.NetworkScenarioTest):
"No IPv4 addresses found in: %s" % ports)
return port_map
def remove_router_interface(
self,
router_id,
subnet_id,
router_client=None):
if router_client is None:
router_client = self.routers_client
router_client.remove_router_interface(router_id,
subnet_id=subnet_id)
def update_subnet(self, subnet_id, subnet_client=None, **kwargs):
if subnet_client is None:
subnet_client = self.subnets_client
result = subnet_client.update_subnet(subnet_id, **kwargs)
subnet = result['subnet']
return subnet
def create_floatingip(self, thing, port_id, external_network_id=None,
ip4=None, client=None):
"""Create a floating IP and associates to a resource/port on Neutron"""
@ -291,7 +309,11 @@ class ApplianceManager(manager.NetworkScenarioTest):
else:
kwargs["config_drive"] = config_drive
if not keypair:
keypair = self.create_keypair()
if clients:
client = clients.keypairs_client
keypair = self.create_keypair(client)
else:
keypair = self.create_keypair()
self.topology_keypairs[keypair['name']] = keypair
kwargs["key_name"] = keypair['name']
else:

102
vmware_nsx_tempest/lib/feature_manager.py
View File

@ -504,6 +504,98 @@ class FeatureManager(traffic_manager.IperfManager):
return port_info['port']['id']
return None
# Vlan backed Tier-1 router operations
def check_downlink_port_created(self, router_op, subnet, port_id):
tag_hit = 0
backend_rtr_id = ''
all_routers = self.nsx.get_logical_routers()
for router in all_routers:
if router_op['name'] in router.get('display_name'):
backend_rtr_id = router['id']
rtr = {'id': backend_rtr_id}
break
if backend_rtr_id:
logical_rtr_ports = self.nsx.get_logical_router_ports(rtr)
for ports in logical_rtr_ports:
for rtr_tag in ports.get('tags'):
if rtr_tag['scope'] == "os-neutron-rport-id" and \
rtr_tag['tag'] == port_id:
tag_hit += 1
continue
if rtr_tag['scope'] == "os-subnet-id" and subnet['id'] == \
rtr_tag['tag']:
tag_hit += 1
ports_info = ports
break
if tag_hit == 2:
if ports_info.get('resource_type') \
== 'LogicalRouterDownLinkPort':
ip_address = ports_info.get('subnets')[
0].get('ip_addresses')
if ip_address:
if not self.\
cmgr_adm.subnets_client.show_subnet(
subnet['id']).get('subnet')[
'gateway_ip'] == ip_address[0]:
raise RuntimeError(
"Router centralized port ip doesn't "
"match with openstack subnet "
"gatewayip")
else:
pass
else:
raise RuntimeError(
"Router_port_id and subnet_id doesn't match at "
"the backend")
else:
raise RuntimeError("Router not created at the backend properly")
def check_centralized_port_created(self, router_op, subnet, port_id):
tag_hit = 0
backend_rtr_id = ''
all_routers = self.nsx.get_logical_routers()
for router in all_routers:
if router_op['name'] in router.get('display_name'):
backend_rtr_id = router['id']
rtr = {'id': backend_rtr_id}
break
if backend_rtr_id:
logical_rtr_ports = self.nsx.get_logical_router_ports(rtr)
for ports in logical_rtr_ports:
for rtr_tag in ports.get('tags'):
if rtr_tag['scope'] == "os-neutron-rport-id" and \
rtr_tag['tag'] == port_id:
tag_hit += 1
continue
if rtr_tag['scope'] == "os-subnet-id" and subnet['id'] == \
rtr_tag['tag']:
tag_hit += 1
ports_info = ports
break
if tag_hit == 2:
if ports_info.get(
'resource_type') \
== 'LogicalRouterCentralizedServicePort':
ip_address = ports_info.get('subnets')[
0].get('ip_addresses')
if ip_address:
if not self.cmgr_adm.subnets_client.\
show_subnet(subnet['id']).\
get('subnet')[
'gateway_ip'] == ip_address[0]:
raise RuntimeError(
"Router centralized port ip doesn't "
"match with openstack subnet "
"gatewayip")
else:
pass
else:
raise RuntimeError(
"Router_port_id and subnet_id doesn't match at "
"the backend")
else:
raise RuntimeError("Router not created at the backend properly")
#
# QoS base class. To get basics of QoS.
#
@ -553,8 +645,8 @@ class FeatureManager(traffic_manager.IperfManager):
max_kbps=max_kbps, max_burst_kbps=max_burst_kbps,
**kwargs)
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.qos_bw_client.delete_bandwidth_limit_rule,
result['bandwidth_limit_rule']['id'], policy_id)
self.qos_bw_client.delete_bandwidth_limit_rule,
result['bandwidth_limit_rule']['id'], policy_id)
return result.get('bandwidth_limit_rule', result)
def delete_bandwidth_limit_rule(self, rule_id, policy_id):
@ -590,14 +682,14 @@ class FeatureManager(traffic_manager.IperfManager):
result = self.qos_dscp_client.create_dscp_marking_rule(
policy_id, **kwargs)
self.addCleanup(test_utils.call_and_ignore_notfound_exc,
self.qos_dscp_client.delete_dscp_marking_rule,
result['dscp_marking_rule']['id'], policy_id)
self.qos_dscp_client.delete_dscp_marking_rule,
result['dscp_marking_rule']['id'], policy_id)
return result.get('dscp_marking_rule', result)
def delete_dscp_marking_rule(self, rule_id, policy_id_or_name):
policy_id = self.get_qos_policy_id(policy_id_or_name)
result = self.qos_dscp_client.delete_dscp_marking_rule(rule_id,
policy_id)
policy_id)
return result.get('dscp_marking_rule', result)
def update_dscp_marking_rule(self, rule_id, policy_id_or_name,

139
vmware_nsx_tempest/tests/api/test_provider_networks.py
View File

@ -45,6 +45,7 @@ class ProviderNetworks(feature_manager.FeatureManager):
def setup_clients(cls):
super(ProviderNetworks, cls).setup_clients()
cls.cmgr_adm = cls.get_client_manager('admin')
cls.cmgr_alt = cls.get_client_manager('alt')
@classmethod
def resource_setup(cls):
@ -65,9 +66,13 @@ class ProviderNetworks(feature_manager.FeatureManager):
cls.vlan_id = tz['id']
vlan_flag = 1
def provider_networks_topoloy(self, tz_id, net_type,
admin_state_up=True):
networks_client = self.cmgr_adm.networks_client
def provider_networks_topoloy(self, net_type,
admin_state_up=True,
tz_id=None,
vlan_id_unique=None,
networks_client=None):
if networks_client is None:
networks_client = self.cmgr_adm.networks_client
if net_type == constants.VXLAN_TYPE:
name = "provider_network_vxlan"
body = {"provider:physical_network": tz_id,
@ -75,10 +80,19 @@ class ProviderNetworks(feature_manager.FeatureManager):
"admin_state_up": admin_state_up}
elif net_type == constants.VLAN_TYPE:
name = "provider_network_vlan"
body = {"provider:segmentation_id": constants.VLAN,
"provider:network_type": net_type,
"provider:physical_network": tz_id,
"admin_state_up": admin_state_up}
if vlan_id_unique is not None:
vlan_id_no = vlan_id_unique
else:
vlan_id_no = constants.VLAN
if tz_id is None:
body = {"provider:segmentation_id": vlan_id_no,
"provider:network_type": net_type,
"admin_state_up": admin_state_up}
else:
body = {"provider:segmentation_id": vlan_id_no,
"provider:network_type": net_type,
"provider:physical_network": tz_id,
"admin_state_up": admin_state_up}
network = self.create_topology_network(name,
networks_client=networks_client,
**body)
@ -87,8 +101,8 @@ class ProviderNetworks(feature_manager.FeatureManager):
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('75c793ed-fdce-4062-a633-2f0a7af5671d')
def test_provider_vxlan_network(self):
provider_network = self.provider_networks_topoloy(self.overlay_id,
constants.VXLAN_TYPE)
provider_network = self.provider_networks_topoloy(
constants.VXLAN_TYPE, tz_id=self.overlay_id)
subnet_client = self.cmgr_adm.subnets_client
subnet_name = provider_network['name'] + '_subnet'
self.create_topology_subnet(subnet_name, provider_network,
@ -97,9 +111,10 @@ class ProviderNetworks(feature_manager.FeatureManager):
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('0307068e-fef1-4d2d-b196-7ffc45c8ec81')
def test_provider_vxlan_network_with_admin_state_down(self):
provider_network = self.provider_networks_topoloy(self.overlay_id,
constants.VXLAN_TYPE,
admin_state_up=False)
provider_network = self.provider_networks_topoloy(
constants.VXLAN_TYPE,
admin_state_up=False,
tz_id=self.overlay_id)
subnet_client = self.cmgr_adm.subnets_client
subnet_name = provider_network['name'] + '_subnet'
self.create_topology_subnet(subnet_name, provider_network,
@ -112,7 +127,7 @@ class ProviderNetworks(feature_manager.FeatureManager):
self.vlan_id += "ab"
self.assertRaises(exceptions.BadRequest,
self.provider_networks_topoloy,
self.vlan_id, constants.VLAN_TYPE)
constants.VLAN_TYPE, tz_id=self.overlay_id)
@decorators.attr(type='nsxv3')
@decorators.attr(type=["negative"])
@ -121,13 +136,14 @@ class ProviderNetworks(feature_manager.FeatureManager):
self.overlay_id += "ab"
self.assertRaises(exceptions.BadRequest,
self.provider_networks_topoloy,
self.overlay_id, constants.VXLAN_TYPE)
constants.VXLAN_TYPE, tz_id=self.overlay_id)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('bcede7c9-cc12-4b7e-800c-cf779c718df1')
def test_provider_vlan_network(self):
provider_network = self.provider_networks_topoloy(self.vlan_id,
constants.VLAN_TYPE)
provider_network = self.provider_networks_topoloy(
constants.VLAN_TYPE,
tz_id=self.vlan_id)
subnet_client = self.cmgr_adm.subnets_client
subnet_name = provider_network['name'] + '_subnet'
kwargs = {"enable_dhcp": "False"}
@ -135,12 +151,93 @@ class ProviderNetworks(feature_manager.FeatureManager):
subnets_client=subnet_client,
**kwargs)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('32c54c02-e152-48a2-a60c-92333ae692d4')
def test_provider_vlan_network_without_vlan_tz_id(self):
provider_network = self.provider_networks_topoloy(
constants.VLAN_TYPE)
subnet_client = self.cmgr_adm.subnets_client
router = self.create_topology_router("rtr-provider")
subnet_name = provider_network['name'] + '_subnet'
kwargs = {"enable_dhcp": "False"}
self.create_topology_subnet(
subnet_name,
provider_network,
subnets_client=subnet_client,
routers_client=self.cmgr_adm.routers_client,
router_id=router['id'],
**kwargs)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('89589446-6b76-40c2-b0cc-069be0101c03')
def test_provider_vlan_network_using_non_admin_should_fail(self):
self.assertRaises(exceptions.Forbidden, self.provider_networks_topoloy,
constants.VLAN_TYPE, tz_id=self.vlan_id,
networks_client=self.cmgr_alt.networks_client)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('4e7e0dce-9fac-44da-92b3-614251cb23a9')
def test_provider_vlan_subnet_using_non_admin_should_fail(self):
provider_network = self.provider_networks_topoloy(
constants.VLAN_TYPE)
subnet_name = provider_network['name'] + '_subnet'
kwargs = {"enable_dhcp": "False"}
self.assertRaises(exceptions.BadRequest, self.create_topology_subnet,
subnet_name, provider_network,
subnets_client=self.cmgr_alt.subnets_client,
**kwargs)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('6a3552ff-1d3e-4c09-a5fa-3aa60dac5500')
def test_provider_vlan_network_without_vlan_tz_id_enable_dhcp(self):
provider_network = self.provider_networks_topoloy(
constants.VLAN_TYPE)
subnet_client = self.cmgr_adm.subnets_client
subnet_name = provider_network['name'] + '_subnet'
kwargs = {"enable_dhcp": "True"}
self.create_topology_subnet(subnet_name, provider_network,
subnets_client=subnet_client,
**kwargs)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('49257047-f8a7-46bd-8323-f41667adbd2a')
def test_provider_vlan_update_subnet(self):
provider_network = self.provider_networks_topoloy(
constants.VLAN_TYPE,
tz_id=self.vlan_id)
subnet_client = self.cmgr_adm.subnets_client
router = self.create_topology_router("rtr-provider")
subnet_name = provider_network['name'] + '_subnet'
kwargs = {"enable_dhcp": "True"}
subnet = self.create_topology_subnet(
subnet_name,
provider_network,
subnets_client=subnet_client,
routers_client=self.cmgr_adm.routers_client,
router_id=router['id'],
**kwargs)
kwargs = {"enable_dhcp": "False"}
self.update_subnet(
subnet['id'],
subnet_client=self.cmgr_adm.subnets_client,
**kwargs)
self.remove_router_interface(
router_id=router['id'],
subnet_id=subnet['id'],
router_client=self.cmgr_adm.routers_client)
kwargs = {"enable_dhcp": "True"}
self.update_subnet(
subnet['id'],
subnet_client=self.cmgr_adm.subnets_client,
**kwargs)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('e070ddd8-3caf-4aaf-8430-ffe5076b4a6b')
def test_provider_vlan_network_with_admin_state_down(self):
provider_network = self.provider_networks_topoloy(self.vlan_id,
constants.VLAN_TYPE,
admin_state_up=False)
provider_network = self.provider_networks_topoloy(
constants.VLAN_TYPE,
admin_state_up=False,
tz_id=self.vlan_id)
subnet_client = self.cmgr_adm.subnets_client
subnet_name = provider_network['name'] + '_subnet'
kwargs = {"enable_dhcp": "False"}
@ -154,7 +251,7 @@ class ProviderNetworks(feature_manager.FeatureManager):
def test_provider_vlan_network_with_vxlan_tz(self):
self.assertRaises(exceptions.BadRequest,
self.provider_networks_topoloy,
self.overlay_id, constants.VLAN_TYPE)
constants.VLAN_TYPE, tz_id=self.overlay_id)
@decorators.attr(type='nsxv3')
@decorators.attr(type=["negative"])
@ -162,4 +259,4 @@ class ProviderNetworks(feature_manager.FeatureManager):
def test_provider_vxlan_network_with_vlan_tz(self):
self.assertRaises(exceptions.BadRequest,
self.provider_networks_topoloy,
self.vlan_id, constants.VXLAN_TYPE)
constants.VXLAN_TYPE, tz_id=self.vlan_id)

275
vmware_nsx_tempest/tests/scenario/test_provider_networks.py
View File

@ -15,6 +15,7 @@
from tempest import config
from tempest.lib import decorators
from tempest.lib import exceptions
from tempest import test
from vmware_nsx_tempest.common import constants
@ -25,26 +26,29 @@ CONF = config.CONF
LOG = constants.log.getLogger(__name__)
class ProviderNetworkScenario(feature_manager.FeatureManager):
"""Test Provider Physical Networks Scenario
class ProviderNetworks(feature_manager.FeatureManager):
"""Test Provider Physical Networks
1. Create Vxlan Provider networks.
2. Create Vlan Provider networks.
3. Create Vlan/Vxlan provider networks using worng ID.
"""
@classmethod
def skip_checks(cls):
super(ProviderNetworkScenario, cls).skip_checks()
if not test.is_extension_enabled('provider', 'network'):
super(ProviderNetworks, cls).skip_checks()
if not test.is_extension_enabled('provider-security-group', 'network'):
msg = "Extension provider-security-group is not enabled."
raise cls.skipException(msg)
@classmethod
def setup_clients(cls):
super(ProviderNetworkScenario, cls).setup_clients()
super(ProviderNetworks, cls).setup_clients()
cls.cmgr_adm = cls.get_client_manager('admin')
@classmethod
def resource_setup(cls):
super(ProviderNetworkScenario, cls).resource_setup()
super(ProviderNetworks, cls).resource_setup()
cls.nsx = nsxv3_client.NSXV3Client(CONF.nsxv3.nsx_manager,
CONF.nsxv3.nsx_user,
CONF.nsxv3.nsx_password)
@ -61,28 +65,42 @@ class ProviderNetworkScenario(feature_manager.FeatureManager):
cls.vlan_id = tz['id']
vlan_flag = 1
def _create_provider_network(self, tz_id, net_type,
admin_state_up=True):
def provider_networks_topoloy(self, net_type,
admin_state_up=True,
tz_id=None,
vlan_id_unique=None):
networks_client = self.cmgr_adm.networks_client
if net_type == constants.VXLAN_TYPE:
name = "network"
name = "provider_network_vxlan"
body = {"provider:physical_network": tz_id,
"provider:network_type": net_type,
"admin_state_up": admin_state_up}
elif net_type == constants.VLAN_TYPE:
name = "network"
body = {"provider:segmentation_id": 1001,
"provider:network_type": net_type,
"provider:physical_network": tz_id,
"admin_state_up": admin_state_up}
network = self.create_topology_network(name, networks_client, **body)
name = "provider_network_vlan"
if vlan_id_unique is not None:
vlan_id_no = vlan_id_unique
else:
vlan_id_no = constants.VLAN
if tz_id is None:
body = {"provider:segmentation_id": vlan_id_no,
"provider:network_type": net_type,
"admin_state_up": admin_state_up}
else:
body = {"provider:segmentation_id": vlan_id_no,
"provider:network_type": net_type,
"provider:physical_network": tz_id,
"admin_state_up": admin_state_up}
network = self.create_topology_network(name,
networks_client=networks_client,
**body)
return network
def provider_network_topology1(self):
sec_rule_client = self.cmgr_adm.security_group_rules_client
sec_client = self.cmgr_adm.security_groups_client
network = self._create_provider_network(self.overlay_id,
constants.VXLAN_TYPE)
network = self.provider_networks_topoloy(
constants.VXLAN_TYPE,
tz_id=self.overlay_id)
kwargs = dict(tenant_id=network['tenant_id'],
security_group_rules_client=sec_rule_client,
security_groups_client=sec_client)
@ -109,8 +127,9 @@ class ProviderNetworkScenario(feature_manager.FeatureManager):
def provider_network_topology2(self):
sec_rule_client = self.cmgr_adm.security_group_rules_client
sec_client = self.cmgr_adm.security_groups_client
network1 = self._create_provider_network(self.overlay_id,
constants.VXLAN_TYPE)
network1 = self.provider_networks_topoloy(
constants.VXLAN_TYPE,
tz_id=self.overlay_id)
kwargs = dict(tenant_id=network1['tenant_id'],
security_group_rules_client=sec_rule_client,
security_groups_client=sec_client)
@ -120,8 +139,9 @@ class ProviderNetworkScenario(feature_manager.FeatureManager):
router = self.create_topology_router(router_name,
routers_client=routers_client)
subnet_client = self.cmgr_adm.subnets_client
network2 = self._create_provider_network(self.overlay_id,
constants.VXLAN_TYPE)
network2 = self.provider_networks_topoloy(
constants.VXLAN_TYPE,
tz_id=self.overlay_id)
subnet_name1 = network1['name'] + 'sub1'
subnet_name2 = network2['name'] + 'sub2'
self.create_topology_subnet(subnet_name1, network1,
@ -143,16 +163,221 @@ class ProviderNetworkScenario(feature_manager.FeatureManager):
security_groups=[{'name': self.sg['name']}],
clients=self.cmgr_adm)
@decorators.idempotent_id('21d11308-8e16-4f41-bd2b-e95588fa4c23')
def test_provider_vlan_networks_using_router(self):
provider_network = self.provider_networks_topoloy(
constants.VLAN_TYPE,
tz_id=self.vlan_id)
subnet_client = self.cmgr_adm.subnets_client
router = self.create_topology_router("rtr-provider")
subnet_name = provider_network['name'] + '_subnet'
kwargs = {"enable_dhcp": "True"}
self.create_topology_subnet(
subnet_name,
provider_network,
subnets_client=subnet_client,
routers_client=self.cmgr_adm.routers_client,
router_id=router['id'],
**kwargs)
provider_network1 = self.provider_networks_topoloy(
constants.VLAN_TYPE,
tz_id=self.vlan_id,
vlan_id_unique=1004)
subnet_name = provider_network1['name'] + '_subnet1'
kwargs = {"enable_dhcp": "True"}
self.create_topology_subnet(
subnet_name,
provider_network1,
subnets_client=subnet_client,
routers_client=self.cmgr_adm.routers_client,
router_id=router['id'],
cidr="19.0.0.0/24",
**kwargs)
@decorators.idempotent_id('7b0fe384-ff1d-441d-b587-1b43fef498d8')
def test_N_S_traffic_using_vlan_network(self):
provider_network = self.provider_networks_topoloy(
constants.VLAN_TYPE,
tz_id=self.vlan_id)
subnet_client = self.cmgr_adm.subnets_client
router = self.create_topology_router("rtr-provider")
subnet_name = provider_network['name'] + '_subnet'
kwargs = {"enable_dhcp": "True"}
self.create_topology_subnet(
subnet_name,
provider_network,
subnets_client=subnet_client,
routers_client=self.cmgr_adm.routers_client,
router_id=router['id'],
**kwargs)
provider_network1 = self.provider_networks_topoloy(
constants.VLAN_TYPE,
tz_id=self.vlan_id,
vlan_id_unique=1004)
subnet_name = provider_network1['name'] + '_subnet1'
kwargs = {"enable_dhcp": "True"}
self.create_topology_subnet(
subnet_name,
provider_network1,
subnets_client=subnet_client,
routers_client=self.cmgr_adm.routers_client,
router_id=router['id'],
cidr="19.0.0.0/24",
**kwargs)
sec_rule_client = self.cmgr_adm.security_group_rules_client
sec_client = self.cmgr_adm.security_groups_client
kwargs = dict(tenant_id=provider_network['tenant_id'],
security_group_rules_client=sec_rule_client,
security_groups_client=sec_client)
sg = self.create_topology_security_group(**kwargs)
self.create_topology_instance(
"provider-server1", [provider_network],
security_groups=[{'name': sg['name']}],
clients=self.cmgr_adm)
self.create_topology_instance(
"provider-server2", [provider_network1],
security_groups=[{'name': sg['name']}],
clients=self.cmgr_adm)
for server_name in self.topology_servers.keys():
server = self.servers_details[server_name].server
fip_data = server.get('floating_ips')[0]
fip = fip_data['floating_ip_address']
self.verify_server_ssh(
server=server, floating_ip=fip)
@decorators.idempotent_id('a813f45a-aad0-489e-a976-e2b48cd6e2f2')
def test_provider_vlan_networks_using_router_Adn_verify(self):
provider_network = self.provider_networks_topoloy(
constants.VLAN_TYPE,
tz_id=self.vlan_id)
subnet_client = self.cmgr_adm.subnets_client
router_op = self.create_topology_router(
"rtr-provider", routers_client=self.cmgr_adm.routers_client)
subnet_name = provider_network['name'] + '_subnet'
kwargs = {"enable_dhcp": "True"}
subnet = self.create_topology_subnet(
subnet_name,
provider_network,
subnets_client=subnet_client,
routers_client=self.cmgr_adm.routers_client,
router_id=router_op['id'],
**kwargs)
ports = self.cmgr_adm.ports_client.list_ports(
project_id=provider_network['project_id'])
for port in ports['ports']:
if port.get('device_owner') == "network:router_interface" and \
port.get(
'fixed_ips')[0]['ip_address'] == subnet['gateway_ip']:
port_id = port['id']
break
self.check_centralized_port_created(router_op, subnet, port_id)
network = self.create_topology_network(network_name="overlay-network")
subnet1 = self.create_topology_subnet(
"overlay_subnet",
network,
cidr="21.1.1.0/24",
subnets_client=self.cmgr_adm.subnets_client,
routers_client=self.cmgr_adm.routers_client,
router_id=router_op['id'])
ports = self.cmgr_adm.ports_client.list_ports(
project_id=provider_network['project_id'])
for port in ports['ports']:
if port.get('device_owner') == "network:router_interface" and \
port.get(
'fixed_ips')[0]['ip_address'] == subnet['gateway_ip']:
port_id = port['id']
break
self.check_downlink_port_created(router_op, subnet1, port_id)
@decorators.idempotent_id('3ca5b0d5-5be0-42e3-b3b1-eb653753fbfe')
def test_vlan_network_attach_router_fails(self):
provider_network = self.provider_networks_topoloy(
constants.VLAN_TYPE,
tz_id=self.vlan_id)
subnet_client = self.cmgr_adm.subnets_client
router = self.create_topology_router("rtr-provider", set_gateway=False)
subnet_name = provider_network['name'] + '_subnet1'
kwargs = {"enable_dhcp": "True"}
self.assertRaises(exceptions.BadRequest,
self.create_topology_subnet,
subnet_name, provider_network,
subnets_client=subnet_client,
routers_client=self.cmgr_adm.routers_client,
router_id=router['id'],
**kwargs)
@decorators.idempotent_id('3e56521f-1c8d-47d5-afa1-de1fd8ac95cd')
def test_vlan_network_with_multi_subnets_attach_router(self):
provider_network = self.provider_networks_topoloy(
constants.VLAN_TYPE,
tz_id=self.vlan_id)
subnet_client = self.cmgr_adm.subnets_client
router = self.create_topology_router("rtr-provider")
subnet_name = provider_network['name'] + '_subnet'
kwargs = {"enable_dhcp": "True"}
self.create_topology_subnet(
subnet_name,
provider_network,
subnets_client=subnet_client,
routers_client=self.cmgr_adm.routers_client,
router_id=router['id'],
**kwargs)
subnet_name = provider_network['name'] + '_subnet1'
kwargs = {"enable_dhcp": "False"}
self.create_topology_subnet(subnet_name, provider_network,
subnets_client=subnet_client,
cidr="19.0.0.0/24",
**kwargs)
self.assertRaises(exceptions.BadRequest,
self.create_topology_subnet,
subnet_name, provider_network,
subnets_client=subnet_client,
routers_client=self.cmgr_adm.routers_client,
router_id=router['id'],
cidr="20.0.0.0/24",
**kwargs)
@decorators.idempotent_id('f7279148-47d5-4451-94fb-2c6f5213fb97')
def test_provider_vlan_network_dhcp_disable_attach_router(self):
provider_network = self.provider_networks_topoloy(
constants.VLAN_TYPE,
tz_id=self.vlan_id)
subnet_client = self.cmgr_adm.subnets_client
router = self.create_topology_router("rtr-provider")
subnet_name = provider_network['name'] + '_subnet'
kwargs = {"enable_dhcp": "False"}
self.create_topology_subnet(
subnet_name,
provider_network,
subnets_client=subnet_client,
routers_client=self.cmgr_adm.routers_client,
router_id=router['id'],
**kwargs)
provider_network1 = self.provider_networks_topoloy(
constants.VLAN_TYPE,
tz_id=self.vlan_id,
vlan_id_unique=1003)
subnet_name = provider_network1['name'] + '_subnet1'
kwargs = {"enable_dhcp": "True"}
self.create_topology_subnet(
subnet_name,
provider_network1,
subnets_client=subnet_client,
routers_client=self.cmgr_adm.routers_client,
router_id=router['id'],
cidr="19.0.0.0/24",
**kwargs)
@decorators.attr(type='nsxv3')
@decorators.idempotent_id('244b51c0-b758-49bc-bcaa-9de744322665')
def test_provider_vxlan_same_network_same_cidr_scenario(self):
self.provider_network_topology1()
self.check_cross_network_connectivity(
self.topology_networks["network"],
self.topology_networks["provider_network_vxlan"],
self.servers_details["server1"].floating_ips[0],
self.servers_details["server1"].server, should_connect=True)
self.check_cross_network_connectivity(
self.topology_networks["network"],
self.topology_networks["provider_network_vxlan"],
self.servers_details["server2"].floating_ips[0],
self.servers_details["server2"].server, should_connect=True)
@ -161,10 +386,10 @@ class ProviderNetworkScenario(feature_manager.FeatureManager):
def test_provider_vxlan_differnet_network_different_cidr_scenario(self):
self.provider_network_topology2()
self.check_cross_network_connectivity(
self.topology_networks["network"],
self.topology_networks["provider_network_vxlan"],
self.servers_details["server1"].floating_ips[0],
self.servers_details["server1"].server, should_connect=True)
self.check_cross_network_connectivity(
self.topology_networks["network"],
self.topology_networks["provider_network_vxlan"],
self.servers_details["server2"].floating_ips[0],
self.servers_details["server2"].server, should_connect=True)