From 5cd98ba2f37659ddd9734ce8335d061250c2bb3e Mon Sep 17 00:00:00 2001 From: Puneet Arora Date: Wed, 14 Mar 2018 00:25:54 +0000 Subject: [PATCH] [Tempest]: Added api/scenario cases for vlan backed tier-1. Added api cases Added sceanrio cases Change-Id: Ie9cefe07e8efc4e409c25092897df54a7f6f2650 --- vmware_nsx_tempest/common/constants.py | 2 +- vmware_nsx_tempest/lib/appliance_manager.py | 34 ++- vmware_nsx_tempest/lib/feature_manager.py | 102 ++++++- .../tests/api/test_provider_networks.py | 139 +++++++-- .../tests/scenario/test_provider_networks.py | 275 ++++++++++++++++-- 5 files changed, 494 insertions(+), 58 deletions(-) diff --git a/vmware_nsx_tempest/common/constants.py b/vmware_nsx_tempest/common/constants.py index c73d547..12a99dd 100644 --- a/vmware_nsx_tempest/common/constants.py +++ b/vmware_nsx_tempest/common/constants.py @@ -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 diff --git a/vmware_nsx_tempest/lib/appliance_manager.py b/vmware_nsx_tempest/lib/appliance_manager.py index a5a7c5e..141062a 100644 --- a/vmware_nsx_tempest/lib/appliance_manager.py +++ b/vmware_nsx_tempest/lib/appliance_manager.py @@ -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: diff --git a/vmware_nsx_tempest/lib/feature_manager.py b/vmware_nsx_tempest/lib/feature_manager.py index 36653f7..6de7175 100644 --- a/vmware_nsx_tempest/lib/feature_manager.py +++ b/vmware_nsx_tempest/lib/feature_manager.py @@ -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, diff --git a/vmware_nsx_tempest/tests/api/test_provider_networks.py b/vmware_nsx_tempest/tests/api/test_provider_networks.py index 74d081d..567c478 100644 --- a/vmware_nsx_tempest/tests/api/test_provider_networks.py +++ b/vmware_nsx_tempest/tests/api/test_provider_networks.py @@ -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) diff --git a/vmware_nsx_tempest/tests/scenario/test_provider_networks.py b/vmware_nsx_tempest/tests/scenario/test_provider_networks.py index 3ba3365..85fb8cc 100644 --- a/vmware_nsx_tempest/tests/scenario/test_provider_networks.py +++ b/vmware_nsx_tempest/tests/scenario/test_provider_networks.py @@ -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)