x
/
group-based-policy
Code Issues Proposed changes

Change to new HostDomainMapping model 

The HostDomainMapping model changed with commit
3635eba169997452c674fe53dab09afcb67cd236 in the
aci-integration-module. This patch uses the new
model, and leverages the change made to the EndpointGroup
resource to support multiple VMM Domains, provided in
commit 2eadd1d1850fc397d79823ba161b99c068036b8e.

Change-Id: Ie705937b022d7cbc9ac0fc7458986e3723729983
This commit is contained in:
Thomas Bachman 2017-11-01 16:07:13 +00:00
parent 6833c41445
commit 6bbbb6cb22
3 changed files with 347 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
gbpservice/neutron/plugins/ml2plus/drivers/apic_aim/mechanism_driver.py
View File

@ -88,6 +88,7 @@ NO_ADDR_SCOPE = object()
DVS_AGENT_KLASS = 'networking_vsphere.common.dvs_agent_rpc_api.DVSClientAPI'
GBP_DEFAULT = 'gbp_default'
DEFAULT_HOST_DOMAIN = '*'
class KeystoneNotificationEndpoint(object):
@ -2254,10 +2255,11 @@ class ApicMechanismDriver(api_plus.MechanismDriver,
return mapping and self._get_network_vrf(mapping)
def get_aim_domains(self, aim_ctx):
vmms = [x.name for x in self.aim.find(aim_ctx, aim_resource.VMMDomain)
if x.type == utils.OPENSTACK_VMM_TYPE]
phys = [x.name for x in
self.aim.find(aim_ctx, aim_resource.PhysicalDomain)]
vmms = [{'name': x.name, 'type': x.type}
for x in self.aim.find(aim_ctx, aim_resource.VMMDomain)
if x.type in utils.KNOWN_VMM_TYPES.values()]
phys = [{'name': x.name}
for x in self.aim.find(aim_ctx, aim_resource.PhysicalDomain)]
return vmms, phys
def _is_external(self, network):
@ -2744,34 +2746,50 @@ class ApicMechanismDriver(api_plus.MechanismDriver,
epg = self._get_network_epg(mapping)
aim_epg = self.aim.get(aim_ctx, epg)
host_id = port[portbindings.HOST_ID]
hd_mapping = aim_infra.HostDomainMapping(host_name=host_id)
aim_hd_mapping = self.aim.get(aim_ctx, hd_mapping)
domain = None
aim_hd_mappings = (self.aim.find(aim_ctx,
aim_infra.HostDomainMappingV2,
host_name=host_id) or
self.aim.find(aim_ctx,
aim_infra.HostDomainMappingV2,
host_name=DEFAULT_HOST_DOMAIN))
domains = []
try:
if is_vmm:
if aim_hd_mapping:
domain = aim_hd_mapping.vmm_domain_name
if not domain:
if aim_hd_mappings:
domains = [{'type': mapping.domain_type,
'name': mapping.domain_name}
for mapping in aim_hd_mappings
if mapping.domain_type in ['OpenStack']]
if not domains:
vmms, phys = self.get_aim_domains(aim_ctx)
self.aim.update(aim_ctx, epg,
openstack_vmm_domain_names=vmms)
elif domain not in aim_epg.openstack_vmm_domain_names:
aim_epg.openstack_vmm_domain_names.append(domain)
vmms = aim_epg.openstack_vmm_domain_names
self.aim.update(aim_ctx, epg,
openstack_vmm_domain_names=vmms)
vmm_domains=vmms)
else:
vmms = aim_epg.vmm_domains[:]
for domain in domains:
if domain not in aim_epg.vmm_domains:
aim_epg.vmm_domains.append(domain)
if vmms != aim_epg.vmm_domains:
vmms = aim_epg.vmm_domains
self.aim.update(aim_ctx, epg, vmm_domains=vmms)
else:
if aim_hd_mapping:
domain = aim_hd_mapping.physical_domain_name
if not domain:
if aim_hd_mappings:
domains = [{'name': mapping.domain_name}
for mapping in aim_hd_mappings
if mapping.domain_type in ['PhysDom']]
if not domains:
vmms, phys = self.get_aim_domains(aim_ctx)
self.aim.update(aim_ctx, epg,
physical_domain_names=phys)
elif domain not in aim_epg.physical_domain_names:
aim_epg.physical_domain_names.append(domain)
phys = aim_epg.physical_domain_names
self.aim.update(aim_ctx, epg,
physical_domain_names=phys)
physical_domains=phys)
else:
phys = aim_epg.physical_domains[:]
for domain in domains:
if domain not in aim_epg.physical_domains:
aim_epg.physical_domains.append(domain)
if phys != aim_epg.physical_domains:
phys = aim_epg.physical_domains
self.aim.update(aim_ctx, epg,
physical_domains=phys)
# this could be caused by concurrent transactions
except db_exc.DBDuplicateEntry as e:
LOG.debug(e)
@ -2789,25 +2807,35 @@ class ApicMechanismDriver(api_plus.MechanismDriver,
else port_context.host)
session = port_context._plugin_context.session
aim_ctx = aim_context.AimContext(session)
hd_mapping = aim_infra.HostDomainMapping(host_name=host_id)
aim_hd_mapping = self.aim.get(aim_ctx, hd_mapping)
if not aim_hd_mapping:
aim_hd_mappings = (self.aim.find(aim_ctx,
aim_infra.HostDomainMappingV2,
host_name=host_id) or
self.aim.find(aim_ctx,
aim_infra.HostDomainMappingV2,
host_name=DEFAULT_HOST_DOMAIN))
if not aim_hd_mappings:
return
if self._is_opflex_type(btm[api.NETWORK_TYPE]):
domain = aim_hd_mapping.vmm_domain_name
if domain:
hd_mappings = self.aim.find(aim_ctx,
aim_infra.HostDomainMapping,
vmm_domain_name=domain)
domain_type = 'OpenStack'
else:
domain = aim_hd_mapping.physical_domain_name
if domain:
hd_mappings = self.aim.find(aim_ctx,
aim_infra.HostDomainMapping,
physical_domain_name=domain)
if not domain:
domain_type = 'PhysDom'
domains = []
hd_mappings = []
for mapping in aim_hd_mappings:
d_type = mapping.domain_type
if d_type == domain_type and mapping.domain_name:
domains.append(mapping.domain_name)
hd_mappings.extend(self.aim.find(aim_ctx,
aim_infra.HostDomainMappingV2,
domain_name=mapping.domain_name,
domain_type=d_type))
if not domains:
return
hosts = [x.host_name for x in hd_mappings]
hosts = [x.host_name
for x in hd_mappings
if x.host_name != DEFAULT_HOST_DOMAIN]
ptg = None
if self.gbp_driver:
ptg, pt = self.gbp_driver._port_id_to_ptg(
@ -2850,17 +2878,26 @@ class ApicMechanismDriver(api_plus.MechanismDriver,
aim_epg = self.aim.get(aim_ctx, epg)
try:
if self._is_opflex_type(btm[api.NETWORK_TYPE]):
if domain in aim_epg.openstack_vmm_domain_names:
aim_epg.openstack_vmm_domain_names.remove(domain)
vmms = aim_epg.openstack_vmm_domain_names
vmms = aim_epg.vmm_domains[:]
for domain in domains:
mapping = {'type': domain_type,
'name': domain}
if mapping in aim_epg.vmm_domains:
aim_epg.vmm_domains.remove(mapping)
if vmms != aim_epg.vmm_domains:
vmms = aim_epg.vmm_domains
self.aim.update(aim_ctx, epg,
openstack_vmm_domain_names=vmms)
vmm_domains=vmms)
else:
if domain in aim_epg.physical_domain_names:
aim_epg.physical_domain_names.remove(domain)
phys = aim_epg.physical_domain_names
phys = aim_epg.physical_domains[:]
for domain in domains:
mapping = {'name': domain}
if mapping in aim_epg.physical_domains:
aim_epg.physical_domains.remove(mapping)
if phys != aim_epg.physical_domains:
phys = aim_epg.physical_domains
self.aim.update(aim_ctx, epg,
physical_domain_names=phys)
physical_domains=phys)
# this could be caused by concurrent transactions
except db_exc.DBDuplicateEntry as e:
LOG.debug(e)

190
gbpservice/neutron/tests/unit/plugins/ml2plus/test_apic_aim.py
View File

@ -5426,6 +5426,13 @@ class TestPortOnPhysicalNode(TestPortVlanNetwork):
self.expected_binding_info = [('apic_aim', 'opflex'),
('openvswitch', 'vlan')]
def _doms(self, domains, with_type=True):
if with_type:
return [(str(dom['name']), str(dom['type']))
for dom in domains]
else:
return [str(dom['name']) for dom in domains]
def test_mixed_ports_on_network(self):
aim_ctx = aim_context.AimContext(self.db_session)
@ -5482,51 +5489,64 @@ class TestPortOnPhysicalNode(TestPortVlanNetwork):
epg1 = self._net_2_epg(net1)
with self.subnet(network={'network': net1}) as sub1:
# "normal" port on opflex host
with self.port(subnet=sub1) as p1:
p1 = self._bind_port_to_host(p1['port']['id'], 'opflex-1')
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set(['vm1', 'vm2']),
set(epg1.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack'),
('vm2', 'OpenStack')]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set([]),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# move port to another host
p1 = self._bind_port_to_host(p1['port']['id'], 'opflex-2')
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set(['vm1', 'vm2']),
set(epg1.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack'),
('vm2', 'OpenStack')]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set([]),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# delete port
self._delete('ports', p1['port']['id'])
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set(['vm1', 'vm2']),
set(epg1.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack'),
('vm2', 'OpenStack')]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set([]),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# port on non-opflex host
with self.port(subnet=sub1) as p2:
p2 = self._bind_port_to_host(p2['port']['id'], 'h1')
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set(['vm1', 'vm2']),
set(epg1.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack'),
('vm2', 'OpenStack')]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set(['ph1', 'ph2']),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# move port to another host
p2 = self._bind_port_to_host(p2['port']['id'], 'h2')
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set(['vm1', 'vm2']),
set(epg1.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack'),
('vm2', 'OpenStack')]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set(['ph1', 'ph2']),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# delete port
self._delete('ports', p2['port']['id'])
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set(['vm1', 'vm2']),
set(epg1.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack'),
('vm2', 'OpenStack')]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set(['ph1', 'ph2']),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
def test_update_sg_rule_with_remote_group_set(self):
# Create network.
@ -5594,27 +5614,42 @@ class TestPortOnPhysicalNode(TestPortVlanNetwork):
def test_mixed_ports_on_network_with_specific_domains(self):
aim_ctx = aim_context.AimContext(self.db_session)
hd_mapping = aim_infra.HostDomainMapping(host_name='opflex-1',
vmm_domain_name='vm1')
hd_mapping = aim_infra.HostDomainMappingV2(host_name='opflex-1',
domain_name='vm1',
domain_type='OpenStack')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMapping(host_name='opflex-2',
vmm_domain_name='vm2')
hd_mapping = aim_infra.HostDomainMappingV2(host_name='opflex-2',
domain_name='vm2',
domain_type='OpenStack')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMapping(host_name='opflex-2a',
vmm_domain_name='vm2')
hd_mapping = aim_infra.HostDomainMappingV2(host_name='opflex-2a',
domain_name='vm2',
domain_type='OpenStack')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMapping(host_name='h1',
physical_domain_name='ph1')
hd_mapping = aim_infra.HostDomainMappingV2(host_name='*',
domain_name='vm3',
domain_type='OpenStack')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMapping(host_name='h2',
physical_domain_name='ph2')
hd_mapping = aim_infra.HostDomainMappingV2(host_name='h1',
domain_name='ph1',
domain_type='PhysDom')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMapping(host_name='h2a',
physical_domain_name='ph2')
hd_mapping = aim_infra.HostDomainMappingV2(host_name='h2',
domain_name='ph2',
domain_type='PhysDom')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMappingV2(host_name='h2a',
domain_name='ph2',
domain_type='PhysDom')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMappingV2(host_name='*',
domain_name='ph3',
domain_type='PhysDom')
self.aim_mgr.create(aim_ctx, hd_mapping)
self._register_agent('opflex-1', AGENT_CONF_OPFLEX)
self._register_agent('opflex-2', AGENT_CONF_OPFLEX)
self._register_agent('opflex-2a', AGENT_CONF_OPFLEX)
self._register_agent('opflex-3', AGENT_CONF_OPFLEX)
net1 = self._make_network(
self.fmt, 'net1', True,
arg_list=('provider:physical_network', 'provider:network_type'),
@ -5623,81 +5658,128 @@ class TestPortOnPhysicalNode(TestPortVlanNetwork):
epg1 = self._net_2_epg(net1)
with self.subnet(network={'network': net1}) as sub1:
# "normal" port on opflex host
with self.port(subnet=sub1) as p1:
p1 = self._bind_port_to_host(p1['port']['id'], 'opflex-1')
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set(['vm1']),
set(epg1.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack')]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set([]),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# move port to another host
p1 = self._bind_port_to_host(p1['port']['id'], 'opflex-2')
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set(['vm2']),
set(epg1.openstack_vmm_domain_names))
self.assertEqual(set([('vm2', 'OpenStack')]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set([]),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# create another port on a host that belongs to the same domain
with self.port(subnet=sub1) as p1a:
p1a = self._bind_port_to_host(p1a['port']['id'], 'opflex-2a')
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set(['vm2']),
set(epg1.openstack_vmm_domain_names))
self.assertEqual(set([('vm2', 'OpenStack')]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set([]),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# delete 1st port
self._delete('ports', p1['port']['id'])
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set(['vm2']),
set(epg1.openstack_vmm_domain_names))
self.assertEqual(set([('vm2', 'OpenStack')]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set([]),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# delete the last port
self._delete('ports', p1a['port']['id'])
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set([]),
set(epg1.openstack_vmm_domain_names))
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set([]),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# create another port on a host that belongs to the wildcard domain
with self.port(subnet=sub1) as p3:
p3 = self._bind_port_to_host(p3['port']['id'], 'opflex-3')
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set([('vm3', 'OpenStack')]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(epg1.physical_domains,
with_type=False)))
# delete the wildcard port
self._delete('ports', p3['port']['id'])
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set([]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(epg1.physical_domains,
with_type=False)))
# port on non-opflex host
with self.port(subnet=sub1) as p2:
p2 = self._bind_port_to_host(p2['port']['id'], 'h1')
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set([]),
set(epg1.openstack_vmm_domain_names))
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set(['ph1']),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# move port to another host
p2 = self._bind_port_to_host(p2['port']['id'], 'h2')
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set([]),
set(epg1.openstack_vmm_domain_names))
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set(['ph2']),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# create another port on a host that belongs to the same domain
with self.port(subnet=sub1) as p2a:
p2a = self._bind_port_to_host(p2a['port']['id'], 'h2a')
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set([]),
set(epg1.openstack_vmm_domain_names))
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set(['ph2']),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# delete 1st port
self._delete('ports', p2['port']['id'])
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set([]),
set(epg1.openstack_vmm_domain_names))
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set(['ph2']),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# delete the last port
self._delete('ports', p2a['port']['id'])
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set([]),
set(epg1.openstack_vmm_domain_names))
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set([]),
set(epg1.physical_domain_names))
set(self._doms(epg1.physical_domains,
with_type=False)))
# create another port on a host that belongs
# to the wildcard mapping
with self.port(subnet=sub1) as p3:
p3 = self._bind_port_to_host(p3['port']['id'], 'h3')
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set([]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set(['ph3']),
set(self._doms(epg1.physical_domains,
with_type=False)))
# delete the wildcard port
self._delete('ports', p3['port']['id'])
epg1 = self.aim_mgr.get(aim_ctx, epg1)
self.assertEqual(set([]),
set(self._doms(epg1.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(epg1.physical_domains,
with_type=False)))
class TestPortOnPhysicalNodeSingleDriver(TestPortOnPhysicalNode):

170
gbpservice/neutron/tests/unit/services/grouppolicy/test_aim_mapping_driver.py
View File

@ -2183,9 +2183,10 @@ class TestPolicyTargetGroupVmmDomains(AIMBaseTestCase):
tenant_name=aim_tenant_name,
app_profile_name=aim_app_profile_name, name=aim_epg_name))
self.assertEqual(set([]),
set(aim_epg.openstack_vmm_domain_names))
set([vmm['name'] for vmm in aim_epg.vmm_domains]))
self.assertEqual(set([]),
set(aim_epg.physical_domain_names))
set([phys['name']
for phys in aim_epg.physical_domains]))
class TestPolicyTargetGroupIpv4(AIMBaseTestCase):
@ -2601,6 +2602,13 @@ class TestPolicyTarget(AIMBaseTestCase):
cfg.CONF.set_override('global_physnet_mtu', 1000, None)
cfg.CONF.set_override('advertise_mtu', True, group='aim_mapping')
def _doms(self, domains, with_type=True):
if with_type:
return [(str(dom['name']), str(dom['type']))
for dom in domains]
else:
return [str(dom['name']) for dom in domains]
def test_policy_target_lifecycle_implicit_port(self):
ptg = self.create_policy_target_group(
name="ptg1")['policy_target_group']
@ -2675,18 +2683,30 @@ class TestPolicyTarget(AIMBaseTestCase):
self._aim_context, aim_resource.EndpointGroup(
tenant_name=aim_tenant_name,
app_profile_name=aim_app_profile_name, name=aim_epg_name))
self.assertEqual(set(['vm1', 'vm2']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack'),
('vm2', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
# move port to another host
self._bind_port_to_host(pt['port_id'], 'h2')
aim_epg = self.aim_mgr.get(aim_ctx, aim_epg)
self.assertEqual(set(['vm1', 'vm2']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack'),
('vm2', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
# delete port
self.delete_policy_target(pt['id'], expected_res_status=204)
aim_epg = self.aim_mgr.get(aim_ctx, aim_epg)
self.assertEqual(set(['vm1', 'vm2']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack'),
('vm2', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
def test_policy_target_with_default_domains_explicit_port(self):
aim_ctx = aim_context.AimContext(self.db_session)
@ -2715,29 +2735,52 @@ class TestPolicyTarget(AIMBaseTestCase):
self._aim_context, aim_resource.EndpointGroup(
tenant_name=aim_tenant_name,
app_profile_name=aim_app_profile_name, name=aim_epg_name))
self.assertEqual(set(['vm1', 'vm2']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack'),
('vm2', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
# move port to another host
self._bind_port_to_host(pt['port_id'], 'h2')
aim_epg = self.aim_mgr.get(aim_ctx, aim_epg)
self.assertEqual(set(['vm1', 'vm2']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack'),
('vm2', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
# delete port
self.delete_policy_target(pt['id'], expected_res_status=204)
aim_epg = self.aim_mgr.get(aim_ctx, aim_epg)
self.assertEqual(set(['vm1', 'vm2']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack'),
('vm2', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
def test_policy_target_with_specific_domains(self):
aim_ctx = aim_context.AimContext(self.db_session)
hd_mapping = aim_infra.HostDomainMapping(host_name='opflex-1',
vmm_domain_name='vm1')
hd_mapping = aim_infra.HostDomainMappingV2(host_name='opflex-1',
domain_name='vm1',
domain_type='OpenStack')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMapping(host_name='opflex-2',
vmm_domain_name='vm2')
hd_mapping = aim_infra.HostDomainMappingV2(host_name='opflex-2',
domain_name='vm2',
domain_type='OpenStack')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMapping(host_name='opflex-2a',
vmm_domain_name='vm2')
hd_mapping = aim_infra.HostDomainMappingV2(host_name='opflex-2a',
domain_name='vm2',
domain_type='OpenStack')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMappingV2(host_name='*',
domain_name='phys1',
domain_type='PhysDom')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMappingV2(host_name='opflex-1',
domain_name='phys2',
domain_type='PhysDom')
self.aim_mgr.create(aim_ctx, hd_mapping)
ptg = self.create_policy_target_group(
@ -2754,41 +2797,66 @@ class TestPolicyTarget(AIMBaseTestCase):
self._aim_context, aim_resource.EndpointGroup(
tenant_name=aim_tenant_name,
app_profile_name=aim_app_profile_name, name=aim_epg_name))
self.assertEqual(set(['vm1']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
# move port to another host
self._bind_port_to_host(pt['port_id'], 'opflex-2')
aim_epg = self.aim_mgr.get(aim_ctx, aim_epg)
self.assertEqual(set(['vm2']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm2', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
# create another port on a host that belongs to the same domain
pt1 = self.create_policy_target(
policy_target_group_id=ptg['id'])['policy_target']
self._bind_port_to_host(pt1['port_id'], 'opflex-2a')
aim_epg = self.aim_mgr.get(aim_ctx, aim_epg)
self.assertEqual(set(['vm2']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm2', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
# delete 1st port
self.delete_policy_target(pt['id'], expected_res_status=204)
aim_epg = self.aim_mgr.get(aim_ctx, aim_epg)
self.assertEqual(set(['vm2']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm2', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
# delete the last port
self.delete_policy_target(pt1['id'], expected_res_status=204)
aim_epg = self.aim_mgr.get(aim_ctx, aim_epg)
self.assertEqual(set([]),
set(aim_epg.openstack_vmm_domain_names))
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains)))
def test_policy_target_with_specific_domains_explicit_port(self):
aim_ctx = aim_context.AimContext(self.db_session)
hd_mapping = aim_infra.HostDomainMapping(host_name='opflex-1',
vmm_domain_name='vm1')
hd_mapping = aim_infra.HostDomainMappingV2(host_name='opflex-1',
domain_name='vm1',
domain_type='OpenStack')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMapping(host_name='opflex-2',
vmm_domain_name='vm2')
hd_mapping = aim_infra.HostDomainMappingV2(host_name='opflex-2',
domain_name='vm2',
domain_type='OpenStack')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMapping(host_name='opflex-2a',
vmm_domain_name='vm2')
hd_mapping = aim_infra.HostDomainMappingV2(host_name='opflex-2a',
domain_name='vm2',
domain_type='OpenStack')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMappingV2(host_name='*',
domain_name='phys1',
domain_type='PhysDom')
self.aim_mgr.create(aim_ctx, hd_mapping)
hd_mapping = aim_infra.HostDomainMappingV2(host_name='opflex-1',
domain_name='phys2',
domain_type='PhysDom')
self.aim_mgr.create(aim_ctx, hd_mapping)
with self.port() as port:
port_id = port['port']['id']
@ -2807,13 +2875,19 @@ class TestPolicyTarget(AIMBaseTestCase):
self._aim_context, aim_resource.EndpointGroup(
tenant_name=aim_tenant_name,
app_profile_name=aim_app_profile_name, name=aim_epg_name))
self.assertEqual(set(['vm1']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm1', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
# move port to another host
self._bind_port_to_host(port_id, 'opflex-2')
aim_epg = self.aim_mgr.get(aim_ctx, aim_epg)
self.assertEqual(set(['vm2']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm2', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
with self.port() as port1:
# create another port on a host that belongs to the same domain
port_id1 = port1['port']['id']
@ -2823,18 +2897,26 @@ class TestPolicyTarget(AIMBaseTestCase):
port_id=port_id1)['policy_target']
aim_epg = self.aim_mgr.get(aim_ctx, aim_epg)
self.assertEqual(set(['vm2']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm2', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
# delete 1st pt
self.delete_policy_target(pt['id'], expected_res_status=204)
aim_epg = self.aim_mgr.get(aim_ctx, aim_epg)
self.assertEqual(set(['vm2']),
set(aim_epg.openstack_vmm_domain_names))
self.assertEqual(set([('vm2', 'OpenStack')]),
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains,
with_type=False)))
# delete the last pt
self.delete_policy_target(pt1['id'], expected_res_status=204)
aim_epg = self.aim_mgr.get(aim_ctx, aim_epg)
self.assertEqual(set([]),
set(aim_epg.openstack_vmm_domain_names))
set(self._doms(aim_epg.vmm_domains)))
self.assertEqual(set([]),
set(self._doms(aim_epg.physical_domains)))
def _verify_gbp_details_assertions(self, mapping, req_mapping, port_id,
expected_epg_name, expected_epg_tenant,