class BaseEPUMStoreTests(unittest.TestCase):
def setUp(self):
self.store = LocalEPUMStore(service_name="EPUM")
def test_simple_add(self):
config = {}
self.store.add_domain("caller01", "testing01", config)
domain = self.store.get_domain("caller01", "testing01")
self.assertEqual("testing01", domain.domain_id)
self.assertEqual("caller01", domain.owner)
# try to create again, should be name clash
self.assertRaises(WriteConflictError, self.store.add_domain,
"caller01", "testing01", config)
# but another caller should be able to create the same name
self.store.add_domain("caller02", "testing01", config)
domain = self.store.get_domain("caller02", "testing01")
self.assertEqual("testing01", domain.domain_id)
self.assertEqual("caller02", domain.owner)
# and first should still exist
domain = self.store.get_domain("caller01", "testing01")
self.assertEqual("testing01", domain.domain_id)
self.assertEqual("caller01", domain.owner)
def test_add_remove_definitions(self):
definition01 = {
"name": "definition01",
"description": "Domain definition 01",
"engine_class": "epu.decisionengine.impls.simplest.SimplestEngine",
"health": {
"monitor_health": True
}
}
definition02 = {
"name": "definition02",
"description": "Domain definition 02",
"engine_class": "epu.decisionengine.impls.needy.NeedyEngine",
"health": {
"monitor_health": False
}
}
self.store.add_domain_definition("definition01", definition01)
self.store.add_domain_definition("definition02", definition02)
definitions = self.store.list_domain_definitions()
self.assertEqual(2, len(self.store.list_domain_definitions()))
self.assertIn("definition01", definitions)
self.assertIn("definition02", definitions)
domain_definition = self.store.get_domain_definition("definition01")
self.assertEqual("definition01", domain_definition.definition_id)
self.assertEqual(definition01, domain_definition.definition)
domain_definition = self.store.get_domain_definition("definition02")
self.assertEqual("definition02", domain_definition.definition_id)
self.assertEqual(definition02, domain_definition.definition)
self.store.remove_domain_definition("definition01")
definitions = self.store.list_domain_definitions()
self.assertEqual(1, len(self.store.list_domain_definitions()))
self.assertIn("definition02", definitions)
def test_domain_configs(self):
"""
Create one domain with a certain configuration. Test that initial conf and
later conf additions work properly.
"""
owner = "David"
engine_class = "epu.decisionengine.impls.simplest.SimplestEngine"
general = {EPUM_CONF_ENGINE_CLASS: engine_class}
health = {EPUM_CONF_HEALTH_MONITOR: False}
engine = {CONF_PRESERVE_N: 2}
config = {EPUM_CONF_GENERAL: general, EPUM_CONF_ENGINE: engine, EPUM_CONF_HEALTH: health}
self.store.add_domain(owner, "testing02", config)
domain = self.store.get_domain(owner, "testing02")
general_out = domain.get_general_config()
self.assertTrue(isinstance(general_out, dict))
self.assertTrue(EPUM_CONF_ENGINE_CLASS in general_out)
self.assertEqual(engine_class, general_out[EPUM_CONF_ENGINE_CLASS])
engine_out = domain.get_engine_config()
self.assertTrue(isinstance(engine_out, dict))
self.assertTrue(CONF_PRESERVE_N in engine_out)
self.assertEqual(2, engine_out[CONF_PRESERVE_N])
health_out = domain.get_health_config()
self.assertTrue(isinstance(health_out, dict))
self.assertTrue(EPUM_CONF_HEALTH_MONITOR in health_out)
self.assertEqual(False, health_out[EPUM_CONF_HEALTH_MONITOR])
health_enabled = domain.is_health_enabled()
self.assertFalse(health_enabled)
def test_active_removed_epums_simple(self):
owner = "David"
engine_class = "epu.decisionengine.impls.simplest.SimplestEngine"
general = {EPUM_CONF_ENGINE_CLASS: engine_class}
health = {EPUM_CONF_HEALTH_MONITOR: False}
engine = {CONF_PRESERVE_N: 2}
config = {EPUM_CONF_GENERAL: general, EPUM_CONF_ENGINE: engine, EPUM_CONF_HEALTH: health}
self.store.add_domain(owner, "active01", config)
self.store.add_domain(owner, "removed02", config)
r = self.store.get_domain(owner, "removed02")
# make sure they both come out of the store list
all_domains = self.store.get_all_domains()
self.assertEqual(len(all_domains), 2)
# mark for removal. This doesn't actually remove it from the
# store because the instances may need to be shut down first.
r.remove()
self.assertTrue(r.is_removed())
# make sure they both come out of the store lists
all_domains = self.store.get_all_domains()
self.assertEqual(len(all_domains), 2)
self.store.remove_domain(owner, "removed02")
# make sure they both come out of the store lists
all_domains = self.store.get_all_domains()
self.assertEqual(len(all_domains), 1)
def test_config(self):
domain = self.store.add_domain("David", "dom0", {})
empty = domain.get_engine_config()
self.assertIsInstance(empty, dict)
self.assertFalse(empty)
empty = domain.get_engine_config(keys=('not', 'real', 'keys'))
self.assertIsInstance(empty, dict)
self.assertFalse(empty)
domain.add_engine_config({'a_string': 'thisisastring',
'a_list': [1, 2, 3], 'a_number': 1.23})
cfg = domain.get_engine_config(keys=['a_string'])
self.assertEqual(cfg, {'a_string': 'thisisastring'})
cfg = domain.get_engine_config()
self.assertEqual(cfg, {'a_string': 'thisisastring',
'a_list': [1, 2, 3], 'a_number': 1.23})
domain.add_engine_config({'a_dict': {"akey": {'fpp': 'bar'}, "blah": 5},
"a_list": [4, 5, 6]})
cfg = domain.get_engine_config()
self.assertEqual(cfg, {'a_string': 'thisisastring',
'a_list': [4, 5, 6], 'a_number': 1.23,
'a_dict': {"akey": {'fpp': 'bar'}, "blah": 5}})
cfg = domain.get_engine_config(keys=('a_list', 'a_number'))
self.assertEqual(cfg, {'a_list': [4, 5, 6], 'a_number': 1.23})
def test_instances_put_get_3(self):
self._instances_put_get(3)
def test_instances_put_get_100(self):
self._instances_put_get(100)
def test_instances_put_get_301(self):
self._instances_put_get(301)
def _instances_put_get(self, count):
domain = self.store.add_domain("David", "dom0", {})
instances = []
instance_ids = set()
for i in range(count):
instance = CoreInstance(instance_id=str(uuid.uuid4()), launch_id=str(uuid.uuid4()),
site="Chicago", allocation="small", state="Illinois")
instances.append(instance)
instance_ids.add(instance.instance_id)
domain.add_instance(instance)
found_ids = domain.get_instance_ids()
found_ids = set(found_ids)
log.debug("Put %d instances, got %d instance IDs", count, len(found_ids))
self.assertEqual(len(found_ids), len(instance_ids))
self.assertEqual(found_ids, instance_ids)
