def test_router_matches_to_l3domain(self):
# Create a router
name = data_utils.rand_name('router-')
create_body = self.routers_client.create_router(
name=name,
external_gateway_info={
"network_id": CONF.network.public_network_id
},
admin_state_up=False)
router = create_body['router']
self.addCleanup(self.routers_client.delete_router, router['id'])
self.assertEqual(router['name'], name)
vsd_l3domain = self.MatchingVsdl3domain(self,
router).get_by_external_id()
vsd_l3domain.has_zones(
with_external_id=ExternalId(router['id']).at_cms_id())
vsd_l3domain.has_permissions(
with_external_id=ExternalId(router['tenant_id']).at_cms_id())
vsd_l3domain.has_egress_acl_template(
with_external_id=ExternalId(router['id']).at_cms_id())
vsd_l3domain.has_ingress_acl_template(
with_external_id=ExternalId(router['id']).at_cms_id())
vsd_l3domain.has_forwarding_policy_template(
with_external_id=ExternalId(router['id']).at_cms_id())
# Delete
vsd_l3domain.verify_cannot_delete()
def _create_and_validate_os_managed_subnet(self,
reload_session=True,
validate_equals=True):
# Provision OpenStack network
if reload_session:
network = self.create_network(manager=self.get_client_manager())
ipv4_subnet = self.create_subnet(network,
manager=self.get_client_manager())
value = self.manager.subnets_client.tenant_name + '-update'
else:
network = self.create_network(manager=self.manager)
ipv4_subnet = self.create_subnet(network, manager=self.manager)
value = self.manager.subnets_client.tenant_name
# When I create an IPv4 subnet
self.assertIsNotNone(ipv4_subnet)
# Then a VSD L2 domain is created with type IPv4
vsd_l2_domain = self.vsd.get_l2domain(
vspk_filter='externalID == "{}"'.format(
ExternalId(ipv4_subnet['id']).at_cms_id()))
self.assertIsNotNone(vsd_l2_domain)
vsd_group = self.nuage_client.get_usergroup(
netpart_name=net_partition_name,
parent=nuage_constants.L2_DOMAIN,
parent_id=vsd_l2_domain.id)
self._validate_user_group_description(validate_equals, value,
vsd_group)
def _create_and_validate_on_router_create(self,
reload_session=True,
validate_equals=True):
# Provision OpenStack network
if reload_session:
value = self.manager.routers_client.tenant_name + '-update'
router = self.create_router(manager=self.get_client_manager())
else:
router = self.create_router(manager=self.manager)
value = self.manager.routers_client.tenant_name
self.assertIsNotNone(router)
vsd_l3_domain = self.vsd.get_l3domain(
vspk_filter='externalID == "{}"'.format(
ExternalId(router['id']).at_cms_id()))
self.assertIsNotNone(vsd_l3_domain)
vsd_l3_domain_zones = self.nuage_client.get_zone(
parent_id=vsd_l3_domain.id)
self.assertIsNotNone(vsd_l3_domain_zones)
for vsd_l3_domain_zone in vsd_l3_domain_zones:
if '-pub-' not in vsd_l3_domain_zone['name']:
vsd_group = self.nuage_client.get_usergroup(
netpart_name=net_partition_name,
parent=nuage_constants.ZONE,
parent_id=vsd_l3_domain_zone['ID'])
self._validate_user_group_description(validate_equals, value,
vsd_group)
def has_dhcp_options(self, with_external_id=None):
# vsd dhcp_options object has external ID
vsd_dhcp_options = self.test.nuage_client.get_dhcpoption(
parent=n_constants.VPORT, parent_id=self.vsd_vport['ID'])
self.test.assertEqual(len(vsd_dhcp_options), len(extra_dhcp_opts),
"dhcp_options not found by VSD parent ID")
if with_external_id is None:
self.test.assertIsNone(vsd_dhcp_options[0]['externalID'])
else:
vsd_dhcp_options = self.test.nuage_client.\
get_child_resource(
resource=n_constants.VPORT,
resource_id=self.vsd_vport['ID'],
child_resource=n_constants.DHCPOPTION,
filters='externalID',
filter_values=with_external_id)
self.test.assertEqual(len(vsd_dhcp_options),
len(extra_dhcp_opts),
"dhcp_options not found by ExternalID")
for vsd_dhcp_option in vsd_dhcp_options:
self.test.assertEqual(
with_external_id,
ExternalId(vsd_dhcp_option['externalID']).at_cms_id())
def _verify_vsd_policy_grp(self,
remote_group_id,
nuage_domain=None,
name=None):
if not nuage_domain:
nuage_domain = self.nuage_any_domain
nuage_policy_grps = self.nuage_client.get_policygroup(
self.nuage_domain_type, nuage_domain[0]['ID'])
self.assertGreater(len(nuage_policy_grps), 0)
found = False
for nuage_policy_grp in nuage_policy_grps:
if ExternalId(remote_group_id).at_cms_id() == \
nuage_policy_grp['externalID']:
found = True
if name and name != nuage_policy_grp['description']:
found = False
self.assertTrue(
found, "Must have nuage policy group"
" with matching security group name")
break
break
self.assertTrue(
found, "Must have nuage policy group"
" with matching externalID")
# can retrieve VSD policy group by the externalID
nuage_policy_grp = self.nuage_client.get_policygroup(
self.nuage_domain_type,
nuage_domain[0]['ID'],
filters='externalID',
filter_values=remote_group_id)
self.assertEqual(nuage_policy_grp[0]['name'], remote_group_id)
def fixme_test_neutron_isolated_shared_subnet_matches_to_l2domain(self):
# Create a network
name = data_utils.rand_name('network-')
body = self.os_admin.networks_client.create_network(
name=name, shared=True)
network = body['network']
self.assertEqual('ACTIVE', network['status'])
# Create a subnet
subnet = self.create_subnet(network, manager=self.admin_manager)
# Create a second subnet
subnet_b = self.create_subnet(network, manager=self.admin_manager)
vsd_l2domain_a = self.MatchingVsdL2domain(
self, subnet).get_by_external_id()
vsd_l2domain_a.has_permissions(
with_external_id=ExternalId(subnet['tenant_id']).at_cms_id())
vsd_l2domain_a.has_group_everybody()
vsd_l2domain_a.has_user(
with_external_id=ExternalId(subnet['tenant_id']).at_openstack())
vsd_l2domain_a.has_egress_acl_template(
with_external_id=ExternalId(subnet['id']).at_cms_id())
vsd_l2domain_a.has_ingress_acl_template(
with_external_id=ExternalId(subnet['id']).at_cms_id())
vsd_l2domain_a.has_forwarding_policy_template(
with_external_id=ExternalId(subnet['id']).at_cms_id())
vsd_l2domain_b = self.MatchingVsdL2domain(
self, subnet_b).get_by_external_id()
vsd_l2domain_b.has_permissions(
with_external_id=ExternalId(subnet_b['tenant_id']).at_cms_id())
vsd_l2domain_b.has_group_everybody()
vsd_l2domain_b.has_user(
with_external_id=ExternalId(subnet_b['tenant_id']).at_openstack())
vsd_l2domain_b.has_egress_acl_template(
with_external_id=ExternalId(subnet_b['id']).at_cms_id())
vsd_l2domain_b.has_ingress_acl_template(
with_external_id=ExternalId(subnet_b['id']).at_cms_id())
vsd_l2domain_b.has_forwarding_policy_template(
with_external_id=ExternalId(subnet_b['id']).at_cms_id())
# Delete
vsd_l2domain_a.verify_cannot_delete()
def test_port_security_fix_openstack_1451_true(self):
# Create a network
name = data_utils.rand_name('network-')
network = self.create_network(network_name=name)
self.addCleanup(self.networks_client.delete_network, network['id'])
subnet = self.create_subnet(network)
name = data_utils.rand_name('port-nosec')
port = self.create_port(
name=name,
network=network,
port_security_enabled=False)
self.addCleanup(self.ports_client.delete_port, port['id'])
# switch port security to true/false
self.ports_client.update_port(port['id'], port_security_enabled=True)
self.ports_client.update_port(port['id'], port_security_enabled=False)
self.ports_client.update_port(port['id'], port_security_enabled=True)
vsd_vport = self.MatchingVsdVPort(
self, port, subnet).get_by_external_id()
if Topology.is_v5:
vsd_vport.has_default_security_policy_group(
with_external_id=ExternalId(
self._build_policy_group_allow_all_external_id(
vsd_vport.vsd_vport['parentID'])).at_cms_id())
vsd_vport.has_default_egress_policy_entries(
with_external_id=ExternalId(subnet['id']).at_cms_id())
vsd_vport.has_default_ingress_policy_entries(
with_external_id=ExternalId(subnet['id']).at_cms_id())
else:
vsd_vport.has_default_security_policy_group(
with_external_id=self.
_build_policy_group_allow_all_external_id())
vsd_vport.has_default_egress_policy_entries(
with_external_id=ExternalId(
n_constants.NUAGE_PLCY_GRP_ALLOW_ALL).at_cms_id())
vsd_vport.has_default_ingress_policy_entries(
with_external_id=ExternalId(
n_constants.NUAGE_PLCY_GRP_ALLOW_ALL).at_cms_id())
# Delete
vsd_vport.verify_cannot_delete()
def test_neutron_isolated_subnet_in_netpartition(self):
# Create a dedicated netpartition
netpartition_a = self._create_netpartition()
netpartition_b = self._create_netpartition()
# Create a network 1 in netpartition A
name = data_utils.rand_name('networkA1')
network_a1 = self.create_network(network_name=name)
subnet_a1 = self.create_subnet(network_a1,
net_partition=netpartition_a['name'])
# Create a network 2 in netpartition A
name = data_utils.rand_name('networkA2')
network_a2 = self.create_network(network_name=name)
subnet_a2 = self.create_subnet(network_a2,
net_partition=netpartition_a['name'])
self.assertIsNotNone(subnet_a2) # dummy check to use local variable
# Create a network 1 in netpartition B
name = data_utils.rand_name('networkB1')
network_b1 = self.create_network(network_name=name)
subnet_b1 = self.create_subnet(network_b1,
net_partition=netpartition_b['name'])
# has only 1 group and 1 user with same External ID as subnet in
# netpartition A
vsd_l2domain_a1 = self.MatchingVsdL2domain(
self, subnet_a1).get_by_external_id(
net_partition_name=netpartition_a['name'])
vsd_l2domain_a1.has_group(
with_external_id=ExternalId(subnet_a1['tenant_id']).at_openstack())
vsd_l2domain_a1.has_user(
with_external_id=ExternalId(subnet_a1['tenant_id']).at_openstack())
# has group and user with same External ID as subnet in netpartition A
vsd_l2domain_b1 = self.MatchingVsdL2domain(
self, subnet_b1).get_by_external_id(
net_partition_name=netpartition_b['name'])
vsd_l2domain_b1.has_group(
with_external_id=ExternalId(subnet_a1['tenant_id']).at_openstack())
vsd_l2domain_b1.has_user(
with_external_id=ExternalId(subnet_a1['tenant_id']).at_openstack())
def get_by_external_id(self):
vsd_network_macro = \
self.test.nuage_client.get_enterprise_net_macro(
netpart_name=self.net_partition['name'])
self.test.assertEqual(1, len(vsd_network_macro),
"should have network macros")
vsd_network_macros = \
self.test.nuage_client.get_enterprise_net_macro(
netpart_name=self.net_partition['name'],
filters='externalID',
filter_values=ExternalId(
self.net_partition['id']).at_openstack())
self.test.assertEqual(1, len(vsd_network_macros))
self.vsd_network_macro = vsd_network_macros[0]
self.test.assertEqual(
ExternalId(self.net_partition['id']).at_openstack(),
self.vsd_network_macro['externalID'])
return self
def has_default_ingress_policy_entries(self, with_external_id=None):
# vsd ingress_acl_template object has external ID
vsd_ingress_acl_templates = \
self.test.nuage_client.get_ingressacl_template(
parent=n_constants.L2_DOMAIN,
parent_id=self.vsd_l2domain['ID'])
self.test.assertEqual(
len(vsd_ingress_acl_templates), 1,
"ingress_acl_template not found by VSD parent ID")
vsd_ingress_security_policy_entries = \
self.test.nuage_client.get_child_resource(
resource=n_constants.INGRESS_ACL_TEMPLATE,
resource_id=vsd_ingress_acl_templates[0]['ID'],
child_resource=n_constants.INGRESS_ACL_ENTRY_TEMPLATE,
filters='locationID',
filter_values=self.vsd_security_policy_group['ID'])
if NUAGE_FEATURES.os_managed_dualstack_subnets:
self.test.assertEqual(
2, len(vsd_ingress_security_policy_entries),
"Should find exact 2 matches for ingress policy entries")
else:
self.test.assertEqual(
1, len(vsd_ingress_security_policy_entries),
"Should find exact 1 match for ingress policy entries")
if with_external_id is None:
self.test.assertIsNone(
vsd_ingress_security_policy_entries[0]['externalID'])
else:
vsd_ingress_security_policy_entries = \
self.test.nuage_client.get_child_resource(
resource=n_constants.INGRESS_ACL_TEMPLATE,
resource_id=vsd_ingress_acl_templates[0]['ID'],
child_resource=n_constants.INGRESS_ACL_ENTRY_TEMPLATE,
filters='externalID',
filter_values=with_external_id)
if NUAGE_FEATURES.os_managed_dualstack_subnets:
self.test.assertEqual(
2, len(vsd_ingress_security_policy_entries),
"Policy groups not found by external id")
else:
self.test.assertEqual(
1, len(vsd_ingress_security_policy_entries),
"Policy group not found by external id")
self.test.assertEqual(
with_external_id,
ExternalId(vsd_ingress_security_policy_entries[0]
['externalID']).at_cms_id())
def _router_create_get_check_vsd(self, nuage_aggregate_flows,
aggregation_flows_enabled,
aggregation_flow_type):
name = data_utils.rand_name('test-NuageRouterAggregateFlows-')
if nuage_aggregate_flows:
router = self.create_router(
router_name=name,
external_network_id=CONF.network.public_network_id,
nuage_aggregate_flows=nuage_aggregate_flows)
else:
router = self.create_router(
router_name=name,
external_network_id=CONF.network.public_network_id)
self.assertIsNotNone(
router, "Unable to create router with "
"nuage_aggregate_flows={}.".format(nuage_aggregate_flows))
self.assertEqual(
nuage_aggregate_flows if nuage_aggregate_flows else 'off',
router.get('nuage_aggregate_flows'),
"nuage_aggregate_flows in create router should be "
"{} but was: {}.".format(
nuage_aggregate_flows if nuage_aggregate_flows else 'off',
router.get('nuage_aggregate_flows')))
router_get = self.get_router(router['id'])
self.assertEqual(
router['nuage_aggregate_flows'],
router_get.get('nuage_aggregate_flows'),
"nuage_aggregate_flows in show router should be "
"{} but was: {}.".format(router['nuage_aggregate_flows'],
router_get.get('nuage_aggregate_flows')))
nuage_router = self.vsd.get_l3domain(
vspk_filter='externalID == "{}"'.format(
ExternalId(router['id']).at_cms_id()))
self.assertIsNotNone(
nuage_router, "Unable to retrieve router from VSD with "
"nuage_aggregate_flows={}.".format(nuage_aggregate_flows))
self.assertEqual(
aggregation_flows_enabled, nuage_router.aggregate_flows_enabled,
"AggregateFlowsEnabled expected to be: {}, "
"but was {} for nuage_aggregate_flows={}.".format(
aggregation_flows_enabled,
nuage_router.aggregate_flows_enabled, nuage_aggregate_flows))
self.assertEqual(
aggregation_flow_type, nuage_router.aggregation_flow_type,
"AggregationFlowType expected to be: {}, but was {} "
"for nuage_aggregate_flows={}.".format(
aggregation_flow_type, nuage_router.aggregation_flow_type,
nuage_aggregate_flows))
LOG.debug("Verified for nuage_aggregate_flows={}.".format(
nuage_aggregate_flows))
def test_neutron_isolated_subnet_matches_to_l2domain(self):
# Create a network
name = data_utils.rand_name('network-')
network = self.create_network(network_name=name)
self.assertEqual('ACTIVE', network['status'])
# Create a subnet
# subnet = self.create_subnet(network)
subnet = self.create_subnet(network)
dhcp_opts = [
{'actualType': 3, 'actualValues': subnet['gateway_ip']}
]
vsd_l2domain = self.MatchingVsdL2domain(
self, subnet).get_by_external_id()
vsd_l2domain.has_l2domain_template(
with_external_id=vsd_l2domain.expected_ext_id(subnet))
vsd_l2domain.has_dhcp_options(
with_external_id=ExternalId(subnet['id']).at_cms_id(),
with_dhcp_opts=dhcp_opts)
vsd_l2domain.has_permissions(
with_external_id=ExternalId(subnet['tenant_id']).at_cms_id())
vsd_l2domain.has_group(
with_external_id=ExternalId(
subnet['tenant_id']).at_openstack())
vsd_l2domain.has_user(
with_external_id=ExternalId(
subnet['tenant_id']).at_openstack())
vsd_l2domain.has_egress_acl_template(
with_external_id=vsd_l2domain.expected_ext_id(subnet))
vsd_l2domain.has_ingress_acl_template(
with_external_id=vsd_l2domain.expected_ext_id(subnet))
vsd_l2domain.has_forwarding_policy_template(
with_external_id=vsd_l2domain.expected_ext_id(subnet))
# Delete
vsd_l2domain.verify_cannot_delete()
def get_by_external_id(self):
vsd_vports = self.test.nuage_client.get_vport(
parent=n_constants.L2_DOMAIN,
parent_id=self.vsd_l2domain['ID'],
filters='externalID',
filter_values=ExternalId(self.port['id']).at_cms_id())
# should have exact 1 match
self.test.assertEqual(len(vsd_vports), 1)
self.vsd_vport = vsd_vports[0]
self.test.assertNotEmpty(self.vsd_vport)
self.test.assertEqual(self.vsd_vport['name'], self.port['id'])
return self
def test_with_vm_on_neutron_port_in_vsd_managed_network_matching_vsd(
self):
net_name = data_utils.rand_name()
cidr = IPNetwork('10.10.100.0/24')
vsd_l2domain_templates = self.create_vsd_dhcpmanaged_l2dom_template(
name=net_name, cidr=cidr, gateway='10.10.100.1')
self.assertEqual(
len(vsd_l2domain_templates), 1,
"Failed to create vsd l2 domain template")
vsd_l2domain_template = vsd_l2domain_templates[0]
vsd_l2domains = self.nuage_client.create_l2domain(
name=net_name, templateId=vsd_l2domain_template['ID'])
self.assertEqual(
len(vsd_l2domains), 1, "Failed to create vsd l2 domain")
vsd_l2domain = vsd_l2domains[0]
self.addCleanup(
self.nuage_client.delete_l2domain, vsd_l2domain['ID'])
network = self.create_network(namestart='network-')
subnet_kwargs = {
'name': network['name'],
'cidr': '10.10.100.0/24',
'gateway_ip': None,
'network_id': network['id'],
'nuagenet': vsd_l2domain['ID'],
'net_partition': Topology.def_netpartition,
'enable_dhcp': True,
'ip_version': 4}
subnet = self.subnets_client.create_subnet(**subnet_kwargs)
self.assertIsNotNone(subnet) # dummy check to use local variable
port = self.create_port(network['id'])
name = data_utils.rand_name('server-smoke')
server = self._create_server(name, network, port['id'])
# get the neutron port, based on the servers MAC address
# (expect only 1 interface)
port_mac = server['addresses'][network['name']][0][
'OS-EXT-IPS-MAC:mac_addr']
ports_response = self.ports_client.list_ports(mac_address=port_mac)
port = ports_response['ports'][0]
vsd_vm = self.MatchingVsdVm(self, server).get_by_external_id()
vsd_vm.has_parent_vm_interface(ExternalId(port['id']).at_cms_id())
# Delete
vsd_vm.verify_cannot_delete()
def get_by_external_id(self):
vsd_vms = self.test.nuage_client.get_vm(
parent=None, parent_id='',
filters='externalID', filter_values=self.vm['id'])
# should have exact 1 match
self.test.assertEqual(len(vsd_vms), 1)
self.vsd_vm = vsd_vms[0]
# VSD UUID is the Openstack VM ID
self.test.assertEqual(self.vsd_vm['UUID'], self.vm['id'])
self.test.assertEqual(
self.vsd_vm['externalID'],
ExternalId(self.vm['id']).at_cms_id())
return self
def test_with_vm_on_neutron_port_matching_vsd(self):
# Create a network
network = self.create_network(namestart='network-')
subnet = self.create_subnet(network, namestart='subnet-')
self.assertIsNotNone(subnet) # dummy check to use local variable
port = self.create_port(network['id'])
name = data_utils.rand_name('server-smoke')
server = self._create_server(name, network, port['id'])
vsd_vm = self.MatchingVsdVm(self, server).get_by_external_id()
vsd_vm.has_parent_vm_interface(ExternalId(port['id']).at_cms_id())
# Delete
vsd_vm.verify_cannot_delete()
def test_port_dhcp_options_matches_to_port(self):
net_name = data_utils.rand_name()
cidr = IPNetwork('10.10.100.0/24')
vsd_l2domain_templates = self.create_vsd_dhcpmanaged_l2dom_template(
name=net_name, cidr=cidr, gateway='10.10.100.1')
self.assertEqual(len(vsd_l2domain_templates), 1,
"Failed to create vsd l2 domain template")
vsd_l2domain_template = vsd_l2domain_templates[0]
vsd_l2domains = self.nuage_client.create_l2domain(
name=net_name, templateId=vsd_l2domain_template['ID'])
self.assertEqual(len(vsd_l2domains), 1,
"Failed to create vsd l2 domain")
vsd_l2domain = vsd_l2domains[0]
self.addCleanup(self.nuage_client.delete_l2domain, vsd_l2domain['ID'])
body = self.networks_client.create_network(name=net_name)
network = body['network']
self.addCleanup(self.networks_client.delete_network, network['id'])
subnet_kwargs = {
'name': network['name'],
'cidr': '10.10.100.0/24',
'gateway_ip': None,
'network_id': network['id'],
'nuagenet': vsd_l2domain['ID'],
'net_partition': Topology.def_netpartition,
'enable_dhcp': True,
'ip_version': 4
}
subnet = self.subnets_client.create_subnet(**subnet_kwargs)
self.assertIsNotNone(subnet) # dummy check to use local variable
name = data_utils.rand_name('extra-dhcp-opt-port-name')
port = self.create_port(name=name,
network=network,
extra_dhcp_opts=extra_dhcp_opts)
self.addCleanup(self.ports_client.delete_port, port['id'])
vsd_vport = self.MatchingVsdVPort(self, port, subnet,
vsd_l2domain).get_by_external_id()
vsd_vport.has_dhcp_options(
with_external_id=ExternalId(port['id']).at_cms_id())
# Delete
vsd_vport.verify_cannot_delete()
def _router_no_op_update_check_no_change(self, nuage_underlay, enable_snat,
pat_enabled, underlay_enabled,
no_op_nuage_underlay,
no_op_enable_snat):
name = data_utils.rand_name('test-NuagePATAndRouteUnderlayDomain-')
router = self.create_router(manager=self.admin_manager,
router_name=name,
external_network_id=self.ext_net_id,
external_gateway_info_on=enable_snat
is not None,
enable_snat=enable_snat,
nuage_underlay=nuage_underlay)
self.assertIsNotNone(router, "Unable to create router.")
updated = self.update_router(router,
manager=self.admin_manager,
external_network_id=self.ext_net_id,
external_gateway_info_on=no_op_enable_snat
is not None,
enable_snat=no_op_enable_snat,
nuage_underlay=no_op_nuage_underlay)
self.assertIsNotNone(
updated, "Unable to update router with "
"nuage_underlay={}, "
"ext_gw_info.enable_snat={}".format(nuage_underlay, enable_snat))
nuage_router = self.vsd.get_l3domain(
vspk_filter='externalID == "{}"'.format(
ExternalId(router['id']).at_cms_id()))
self.assertIsNotNone(
nuage_router, "Unable to retrieve router from VSD with "
" nuage_underlay={}, "
"ext_gw_info.enable_snat={}".format(nuage_underlay, enable_snat))
self.assertEqual(
pat_enabled, nuage_router.pat_enabled,
"PATEnabled expected to be: {}, but was {} "
"for nuage_underlay={}, ext_gw_info.enable_snat={}.".format(
pat_enabled, nuage_router.pat_enabled, nuage_underlay,
enable_snat))
self.assertEqual(
underlay_enabled, nuage_router.underlay_enabled,
"UnderlayEnabled expected to be: {}, but was {} "
"for nuage_underlay ={}, ext_gw_info.enable_snat={}.".format(
underlay_enabled, nuage_router.underlay_enabled,
nuage_underlay, enable_snat))
LOG.debug("Verified for nuage_underlay={} ,"
"ext_gw_info.enable_snat={}".format(nuage_underlay,
enable_snat))
def test_port_dhcp_options_matches_to_port(self):
# Create a network
name = data_utils.rand_name('network-')
network = self.create_network(network_name=name)
self.addCleanup(self.networks_client.delete_network, network['id'])
subnet = self.create_subnet(network)
name = data_utils.rand_name('extra-dhcp-opt-port-name')
port = self.create_port(name=name,
network=network,
extra_dhcp_opts=extra_dhcp_opts)
self.addCleanup(self.ports_client.delete_port, port['id'])
vsd_vport = self.MatchingVsdVPort(self, port,
subnet).get_by_external_id()
vsd_vport.has_dhcp_options(
with_external_id=ExternalId(port['id']).at_cms_id())
# Delete
vsd_vport.verify_cannot_delete()
def test_with_vm_on_neutron_network_matching_vsd(self):
# Create a network
network = self.create_network(namestart='network-')
subnet = self.create_subnet(network, namestart='subnet-')
self.assertIsNotNone(subnet) # dummy check to use local variable
name = data_utils.rand_name('server-smoke')
server = self._create_server(name, network)
# get the neutron port, based on the servers MAC address
# (expect only 1 interface)
port_mac = server['addresses'][network['name']][0][
'OS-EXT-IPS-MAC:mac_addr']
ports_response = self.ports_client.list_ports(mac_address=port_mac)
port = ports_response['ports'][0]
vsd_vm = self.MatchingVsdVm(self, server).get_by_external_id()
vsd_vm.has_parent_vm_interface(ExternalId(port['id']).at_cms_id())
# Delete
vsd_vm.verify_cannot_delete()
def has_permissions(self, with_external_id=None):
for zone in self.vsd_zones:
# vsd permissions object has external ID
vsd_permissions = self.test.nuage_client.get_permissions(
parent=n_constants.ZONE, parent_id=zone['ID'])
self.test.assertEqual(1, len(vsd_permissions),
"VSD Permission not found by parent ID")
group_external_id = \
ExternalId(with_external_id).at_openstack() \
if with_external_id else None
if zone['name'].split('-')[1] == 'pub':
self.test.assertEqual(
vsd_permissions[0]['permittedEntityName'], "Everybody")
self.has_user(group_external_id)
else:
self.test.assertEqual(
self.router['tenant_id'],
vsd_permissions[0]['permittedEntityName'])
self.has_group(group_external_id, for_zone=zone)
self.has_user(group_external_id)
if with_external_id is None:
self.test.assertIsNone(vsd_permissions[0]['externalID'])
else:
# permission object has external ID
self.test.assertEqual(with_external_id,
vsd_permissions[0]['externalID'])
# can find vsd permissions by external ID
vsd_permissions = \
self.test.nuage_client.get_permissions(
parent=n_constants.ZONE,
parent_id=zone['ID'],
filters='externalID',
filter_values=with_external_id)
self.test.assertEqual(
1, len(vsd_permissions),
"VSD Permission not found by ExternalID")
def _router_name_update_check_no_change(self, nuage_aggregate_flows,
aggregation_flows_enabled,
aggregation_flow_type):
name = data_utils.rand_name('test-NuageRouterAggregateFlows-')
if nuage_aggregate_flows:
router = self.create_router(
router_name=name,
external_network_id=CONF.network.public_network_id,
nuage_aggregate_flows=nuage_aggregate_flows)
else:
router = self.create_router(
router_name=name,
external_network_id=CONF.network.public_network_id)
self.assertIsNotNone(router, "Unable to create router.")
name = data_utils.rand_name('test-NuageRouterAggregateFlows2-')
updated = self.update_router(router, name=name)
self.assertIsNotNone(
updated, "Unable to update router with new name for "
"nuage_aggregate_flows={}.".format(nuage_aggregate_flows))
nuage_router = self.vsd.get_l3domain(
vspk_filter='externalID == "{}"'.format(
ExternalId(router['id']).at_cms_id()))
self.assertIsNotNone(
nuage_router, "Unable to retrieve router from VSD with "
"nuage_aggregate_flows={}.".format(nuage_aggregate_flows))
self.assertEqual(
aggregation_flows_enabled, nuage_router.aggregate_flows_enabled,
"AggregateFlowsEnabled expected to be: {}, "
"but was {} for nuage_aggregate_flows={}.".format(
aggregation_flows_enabled,
nuage_router.aggregate_flows_enabled, nuage_aggregate_flows))
self.assertEqual(
aggregation_flow_type, nuage_router.aggregation_flow_type,
"AggregationFlowType expected to be: {}, but was {} "
"for nuage_aggregate_flows={}.".format(
aggregation_flow_type, nuage_router.aggregation_flow_type,
nuage_aggregate_flows))
LOG.debug("Verified for nuage_aggregate_flows={}.".format(
nuage_aggregate_flows))
def test_subnet_attached_to_router_matches_to_l3domain(self):
# Create a network
name = data_utils.rand_name('network-')
network = self.create_network(network_name=name)
# Create a subnet
subnet = self.create_subnet(network)
# Create a router
name = data_utils.rand_name('router-')
create_body = self.routers_client.create_router(
name=name,
external_gateway_info={
"network_id": CONF.network.public_network_id
},
admin_state_up=False)
router = create_body['router']
self.addCleanup(self.routers_client.delete_router, router['id'])
self.assertEqual(router['name'], name)
# Attach subnet to router
# Add router interface with subnet id
self.routers_client.add_router_interface(router['id'],
subnet_id=subnet['id'])
self.addCleanup(self._remove_router_interface_with_subnet_id,
router['id'], subnet['id'])
vsd_l3domain = self.MatchingVsdl3domain(self,
router).get_by_external_id()
vsd_l3domain.has_zones(
with_external_id=ExternalId(router['id']).at_cms_id())
vsd_l3domain.has_subnet(
with_external_id=vsd_l3domain.expected_ext_id(subnet),
subnet=subnet)
# Delete
vsd_l3domain.verify_cannot_delete()
vsd_l3domain.verify_cannot_delete_subnets()
def has_default_security_policy_group(self, with_external_id=None):
# vsd has_default_security_policy_group object has external ID
# vsd_security_policy_groups = self.test.nuage_client.\
# get_policygroup(
# parent=n_constants.POLICYGROUP,
# parent_id=self.vsd_vport['parentID'])
vsd_security_policy_groups = \
self.test.nuage_client.get_child_resource(
resource=n_constants.L2_DOMAIN,
resource_id=self.vsd_vport['parentID'],
child_resource=n_constants.POLICYGROUP)
self.test.assertEqual(1, len(vsd_security_policy_groups),
"policy group not found by VSD parent ID")
self.vsd_security_policy_group = vsd_security_policy_groups[0]
if with_external_id is None:
self.test.assertIsNone(
vsd_security_policy_groups[0]['externalID'])
else:
vsd_security_policy_groups = \
self.test.nuage_client.get_child_resource(
resource=n_constants.L2_DOMAIN,
resource_id=self.vsd_vport['parentID'],
child_resource=n_constants.POLICYGROUP,
filters='externalID',
filter_values=with_external_id)
self.test.assertEqual(1, len(vsd_security_policy_groups),
"policy group not found by ExternalID")
self.test.assertEqual(
with_external_id,
ExternalId(vsd_security_policy_groups[0]
['externalID']).at_cms_id())
def expected_ext_id(subnet):
return ExternalId(subnet['id'] if Topology.
is_v5 else subnet['network_id']).at_cms_id()
def test_external_id_format_default_security_policy_group(self):
external_id = ExternalId(n_constants.NUAGE_PLCY_GRP_ALLOW_ALL +
'@1b501982-2da1-48b9-931b-af49b6ee065f')
self.assertEqual(
external_id.uuid,
n_constants.NUAGE_PLCY_GRP_ALLOW_ALL)
def test_external_id_empty(self):
external_id = ExternalId("")
self.assertEqual(external_id.uuid, "")
def test_external_id_none(self):
external_id = ExternalId(None)
self.assertEqual(external_id.uuid, "")
def test_external_id_format_short(self):
external_id = ExternalId("aa-bb-cc-dd")
self.assertEqual(external_id.uuid, "aa-bb-cc-dd")
def test_external_id_format_cmsid(self):
external_id = ExternalId("aa-bb-cc-dd@ee-ff-gg-hh")
self.assertEqual(external_id.uuid, "aa-bb-cc-dd")
self.assertEqual(external_id.cms, "ee-ff-gg-hh")
