def test_load_mappings(self):
# The load-domains command invokes load-mappings,
# so we don't use it to create hte domains -- we
# have to create them manually
cfg_mappings = [{
'host_name': '*',
'domain_name': 'phys',
'domain_type': 'PhysDom'
}, {
'host_name': '*',
'domain_name': 'phys2',
'domain_type': 'PhysDom'
}, {
'host_name': '*',
'domain_name': 'ostack',
'domain_type': 'OpenStack'
}, {
'host_name': '*',
'domain_name': 'ostack2',
'domain_type': 'OpenStack'
}, {
'host_name': '*',
'domain_name': 'vmware',
'domain_type': 'VMware'
}, {
'host_name': '*',
'domain_name': 'vmware2',
'domain_type': 'VMware'
}]
for mapping in cfg_mappings:
if mapping['domain_type'] is 'PhysDom':
domain = resource.PhysicalDomain(name=mapping['domain_name'])
else:
domain = resource.VMMDomain(type=mapping['domain_type'],
name=mapping['domain_name'])
self.mgr.create(self.ctx, domain)
# Run the load-mappings command, which populates
# the HostDomainMappingV2 table using the domain
# objects found in AIM
self.run_command('manager load-mappings')
mappings = self.mgr.find(self.ctx, infra.HostDomainMappingV2)
db_mappings = [
infra.HostDomainMappingV2(host_name=mapping['host_name'],
domain_type=mapping['domain_type'],
domain_name=mapping['domain_name'])
for mapping in cfg_mappings
]
self.assertEqual(sorted(db_mappings, key=lambda x: x.domain_name),
sorted(mappings, key=lambda x: x.domain_name))
def do_mappings(aim_ctx, manager, replace, vmm_doms=None, phys_doms=None):
if replace:
curr_mappings = manager.find(aim_ctx, infra.HostDomainMappingV2)
for mapping in curr_mappings:
click.echo("Deleting %s: %s" % (type(mapping), mapping.__dict__))
manager.delete(aim_ctx, mapping)
if not vmm_doms:
vmm_doms = manager.find(aim_ctx, resource.VMMDomain)
if not phys_doms:
phys_doms = manager.find(aim_ctx, resource.PhysicalDomain)
doms = vmm_doms + phys_doms
for dom in doms:
if isinstance(dom, resource.PhysicalDomain):
domtype = 'PhysDom'
else:
domtype = dom.type
res = infra.HostDomainMappingV2(host_name=infra.WILDCARD_HOST,
domain_type=domtype,
domain_name=dom.name)
print_resource(manager.create(aim_ctx, res, overwrite=True))
def test_load_domains(self):
# create a VMM and PhysDom first
pre_phys = resource.PhysicalDomain(name='pre-phys')
pre_vmm = resource.VMMDomain(type='OpenStack', name='pre-vmm')
ap = resource.ApplicationProfile(tenant_name='tn1', name='ap')
pre_epg1 = resource.EndpointGroup(
tenant_name='tn1', app_profile_name='ap', name='epg1')
pre_epg2 = resource.EndpointGroup(
tenant_name='tn1', app_profile_name='ap', name='epg2')
self.mgr.create(self.ctx, resource.Tenant(name='tn1'))
self.mgr.create(self.ctx, ap)
self.mgr.create(self.ctx, pre_phys)
self.mgr.create(self.ctx, pre_vmm)
self.mgr.create(self.ctx, pre_epg2)
self.mgr.create(self.ctx, pre_epg1)
self.run_command('manager load-domains --no-mappings')
# Verify pre-existing domains are still there
self.assertIsNotNone(self.mgr.get(self.ctx, pre_phys))
self.assertIsNotNone(self.mgr.get(self.ctx, pre_vmm))
# Also the Domains defined in the config files exist
self.assertIsNotNone(
self.mgr.get(self.ctx, resource.PhysicalDomain(name='phys')))
self.assertIsNotNone(
self.mgr.get(self.ctx, resource.PhysicalDomain(name='phys2')))
self.assertIsNotNone(
self.mgr.get(self.ctx, resource.VMMDomain(type='OpenStack',
name='ostack')))
self.assertIsNotNone(
self.mgr.get(self.ctx, resource.VMMDomain(type='OpenStack',
name='ostack2')))
self.assertIsNotNone(
self.mgr.get(self.ctx, resource.VMMDomain(type='VMware',
name='vmware')))
self.assertIsNotNone(
self.mgr.get(self.ctx, resource.VMMDomain(type='VMware',
name='vmware2')))
# EPGs are still empty
pre_epg1 = self.mgr.get(self.ctx, pre_epg1)
pre_epg2 = self.mgr.get(self.ctx, pre_epg2)
self.assertEqual([], pre_epg1.vmm_domains)
self.assertEqual([], pre_epg1.physical_domains)
self.assertEqual([], pre_epg2.vmm_domains)
self.assertEqual([], pre_epg2.physical_domains)
# Delete one of them, and use the replace flag
self.mgr.delete(self.ctx, resource.VMMDomain(type='OpenStack',
name='ostack2'))
self.run_command('manager load-domains --replace --no-mappings')
# Now only 2 Domains each exist
self.assertEqual(4, len(self.mgr.find(self.ctx, resource.VMMDomain)))
self.assertEqual(2, len(self.mgr.find(self.ctx,
resource.PhysicalDomain)))
# EPGs are still empty
pre_epg1 = self.mgr.get(self.ctx, pre_epg1)
pre_epg2 = self.mgr.get(self.ctx, pre_epg2)
self.assertEqual([], pre_epg1.vmm_domains)
self.assertEqual([], pre_epg1.physical_domains)
self.assertEqual([], pre_epg2.vmm_domains)
self.assertEqual([], pre_epg2.physical_domains)
# now update the current environment
cmd = 'manager load-domains --replace --enforce --no-mappings'
self.run_command(cmd)
pre_epg1 = self.mgr.get(self.ctx, pre_epg1)
pre_epg2 = self.mgr.get(self.ctx, pre_epg2)
def get_vmm(type, name):
return {'type': type, 'name': name}
def get_phys(name):
return {'name': name}
self.assertEqual(sorted([get_vmm('OpenStack', 'ostack'),
get_vmm('OpenStack', 'ostack2'),
get_vmm('VMware', 'vmware'),
get_vmm('VMware', 'vmware2')]),
sorted(pre_epg1.vmm_domains))
self.assertEqual(sorted([get_phys('phys'),
get_phys('phys2')]),
sorted(pre_epg1.physical_domains))
self.assertEqual(sorted([get_vmm('OpenStack', 'ostack'),
get_vmm('OpenStack', 'ostack2'),
get_vmm('VMware', 'vmware'),
get_vmm('VMware', 'vmware2')]),
sorted(pre_epg2.vmm_domains))
self.assertEqual(sorted([get_phys('phys'),
get_phys('phys2')]),
sorted(pre_epg2.physical_domains))
# re-run the command, but populate the domain mappings
self.run_command('manager load-domains --replace --enforce')
pre_epg1 = self.mgr.get(self.ctx, pre_epg1)
pre_epg2 = self.mgr.get(self.ctx, pre_epg2)
def get_vmm(type, name):
return {'type': type, 'name': name}
def get_phys(name):
return {'name': name}
# The load-domains should creat host domain mappings with
# wildcard entries for every entry in the configuration file
existing_mappings = [{'domain_type': 'PhysDom',
'host_name': '*',
'domain_name': 'phys'},
{'domain_type': 'PhysDom',
'host_name': '*',
'domain_name': 'phys2'},
{'domain_type': 'OpenStack',
'host_name': '*',
'domain_name': 'ostack'},
{'domain_type': 'OpenStack',
'host_name': '*',
'domain_name': 'ostack'},
{'domain_type': 'VMware',
'host_name': '*',
'domain_name': 'vmware'},
{'domain_type': 'VMware',
'host_name': '*',
'domain_name': 'vmware2'}]
for mapping in existing_mappings:
mapping = infra.HostDomainMappingV2(
host_name=mapping['host_name'],
domain_name=mapping['domain_name'],
domain_type=mapping['domain_type'])
try:
self.assertIsNotNone(self.mgr.get(self.ctx, mapping))
except Exception:
self.assertFalse(True)
self.assertEqual(sorted([get_vmm('OpenStack', 'ostack'),
get_vmm('OpenStack', 'ostack2'),
get_vmm('VMware', 'vmware'),
get_vmm('VMware', 'vmware2')]),
sorted(pre_epg1.vmm_domains))
self.assertEqual(sorted([get_phys('phys'),
get_phys('phys2')]),
sorted(pre_epg1.physical_domains))
self.assertEqual(sorted([get_vmm('OpenStack', 'ostack'),
get_vmm('OpenStack', 'ostack2'),
get_vmm('VMware', 'vmware'),
get_vmm('VMware', 'vmware2')]),
sorted(pre_epg2.vmm_domains))
self.assertEqual(sorted([get_phys('phys'),
get_phys('phys2')]),
sorted(pre_epg2.physical_domains))
# re-run the command, with host-specific domain mappings populated.
# This should cause an exception
self.mgr.create(self.ctx, infra.HostDomainMappingV2(
host_name='host1',
domain_name='ostack10',
domain_type='OpenStack'))
self.run_command('manager load-domains --enforce', raises=True)
def _test_load_mappings_preexisting_mappings(self, replace=False):
# The load-domains command invokes load-mappings,
# so we don't use it to create hte domains -- we
# have to create them manually
cfg_mappings = [{'domain_type': 'PhysDom',
'host_name': '*',
'domain_name': 'phys'},
{'domain_type': 'PhysDom',
'host_name': '*',
'domain_name': 'phys2'},
{'domain_type': 'OpenStack',
'host_name': '*',
'domain_name': 'ostack'},
{'domain_type': 'OpenStack',
'host_name': '*',
'domain_name': 'ostack2'},
{'domain_type': 'VMware',
'host_name': '*',
'domain_name': 'vmware'},
{'domain_type': 'VMware',
'host_name': '*',
'domain_name': 'vmware2'}]
existing_mappings = [{'domain_type': 'PhysDom',
'host_name': '*',
'domain_name': 'phys3'},
{'domain_type': 'PhysDom',
'host_name': 'vm1',
'domain_name': 'phys4'},
{'domain_type': 'OpenStack',
'host_name': '*',
'domain_name': 'ostack3'},
{'domain_type': 'OpenStack',
'host_name': 'vm2',
'domain_name': 'ostack4'},
{'domain_type': 'VMware',
'host_name': '*',
'domain_name': 'vmware3'},
{'domain_type': 'VMware',
'host_name': 'vm3',
'domain_name': 'vmware4'}]
for mapping in cfg_mappings:
if mapping['domain_type'] is 'PhysDom':
domain = resource.PhysicalDomain(name=mapping['domain_name'],
monitored=True)
else:
domain = resource.VMMDomain(type=mapping['domain_type'],
name=mapping['domain_name'],
monitored=True)
self.mgr.create(self.ctx, domain)
# Create some existing mappings, both host-specific
# and wildcarded
for mapping in existing_mappings:
mapping_obj = infra.HostDomainMappingV2(
host_name=mapping['host_name'],
domain_name=mapping['domain_name'],
domain_type=mapping['domain_type'])
self.mgr.create(self.ctx, mapping_obj)
mappings = self.mgr.find(self.ctx, infra.HostDomainMappingV2)
# Run the load-mappings command, which populates
# the HostDomainMappingV2 table using the contents
# of the configuration file
cmd = 'manager load-mappings'
if replace:
cmd += ' --replace'
self.run_command(cmd)
mappings = self.mgr.find(self.ctx, infra.HostDomainMappingV2)
if replace:
all_mappings = cfg_mappings
else:
all_mappings = existing_mappings + cfg_mappings
db_mappings = [infra.HostDomainMappingV2(
host_name=mapping['host_name'],
domain_type=mapping['domain_type'],
domain_name=mapping['domain_name'])
for mapping in all_mappings]
self.assertEqual(sorted(db_mappings, key=lambda x: x.domain_name),
sorted(mappings, key=lambda x: x.domain_name))
